strongdm.models

    1# Copyright 2020 StrongDM Inc
    2#
    3# Licensed under the Apache License, Version 2.0 (the "License");
    4# you may not use this file except in compliance with the License.
    5# You may obtain a copy of the License at
    6#
    7#     http://www.apache.org/licenses/LICENSE-2.0
    8#
    9# Unless required by applicable law or agreed to in writing, software
   10# distributed under the License is distributed on an "AS IS" BASIS,
   11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12# See the License for the specific language governing permissions and
   13# limitations under the License.
   14#
   15
   16# This file was generated by protogen. DO NOT EDIT.
   17
   18import collections
   19
   20
   21class AKS:
   22    '''
   23
   24    '''
   25    __slots__ = [
   26        'bind_interface',
   27        'certificate_authority',
   28        'client_certificate',
   29        'client_key',
   30        'egress_filter',
   31        'healthcheck_namespace',
   32        'healthy',
   33        'hostname',
   34        'id',
   35        'name',
   36        'port',
   37        'port_override',
   38        'remote_identity_group_id',
   39        'remote_identity_healthcheck_username',
   40        'secret_store_id',
   41        'tags',
   42    ]
   43
   44    def __init__(
   45        self,
   46        bind_interface=None,
   47        certificate_authority=None,
   48        client_certificate=None,
   49        client_key=None,
   50        egress_filter=None,
   51        healthcheck_namespace=None,
   52        healthy=None,
   53        hostname=None,
   54        id=None,
   55        name=None,
   56        port=None,
   57        port_override=None,
   58        remote_identity_group_id=None,
   59        remote_identity_healthcheck_username=None,
   60        secret_store_id=None,
   61        tags=None,
   62    ):
   63        self.bind_interface = bind_interface if bind_interface is not None else ''
   64        '''
   65         Bind interface
   66        '''
   67        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
   68        '''
   69
   70        '''
   71        self.client_certificate = client_certificate if client_certificate is not None else ''
   72        '''
   73
   74        '''
   75        self.client_key = client_key if client_key is not None else ''
   76        '''
   77
   78        '''
   79        self.egress_filter = egress_filter if egress_filter is not None else ''
   80        '''
   81         A filter applied to the routing logic to pin datasource to nodes.
   82        '''
   83        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
   84        '''
   85         The path used to check the health of your connection.  Defaults to `default`.
   86        '''
   87        self.healthy = healthy if healthy is not None else False
   88        '''
   89         True if the datasource is reachable and the credentials are valid.
   90        '''
   91        self.hostname = hostname if hostname is not None else ''
   92        '''
   93
   94        '''
   95        self.id = id if id is not None else ''
   96        '''
   97         Unique identifier of the Resource.
   98        '''
   99        self.name = name if name is not None else ''
  100        '''
  101         Unique human-readable name of the Resource.
  102        '''
  103        self.port = port if port is not None else 0
  104        '''
  105
  106        '''
  107        self.port_override = port_override if port_override is not None else 0
  108        '''
  109
  110        '''
  111        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  112        '''
  113
  114        '''
  115        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  116        '''
  117
  118        '''
  119        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  120        '''
  121         ID of the secret store containing credentials for this resource, if any.
  122        '''
  123        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  124        '''
  125         Tags is a map of key, value pairs.
  126        '''
  127
  128    def __repr__(self):
  129        return '<sdm.AKS ' + \
  130            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  131            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  132            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  133            'client_key: ' + repr(self.client_key) + ' ' +\
  134            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  135            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  136            'healthy: ' + repr(self.healthy) + ' ' +\
  137            'hostname: ' + repr(self.hostname) + ' ' +\
  138            'id: ' + repr(self.id) + ' ' +\
  139            'name: ' + repr(self.name) + ' ' +\
  140            'port: ' + repr(self.port) + ' ' +\
  141            'port_override: ' + repr(self.port_override) + ' ' +\
  142            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  143            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  144            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  145            'tags: ' + repr(self.tags) + ' ' +\
  146            '>'
  147
  148    def to_dict(self):
  149        return {
  150            'bind_interface': self.bind_interface,
  151            'certificate_authority': self.certificate_authority,
  152            'client_certificate': self.client_certificate,
  153            'client_key': self.client_key,
  154            'egress_filter': self.egress_filter,
  155            'healthcheck_namespace': self.healthcheck_namespace,
  156            'healthy': self.healthy,
  157            'hostname': self.hostname,
  158            'id': self.id,
  159            'name': self.name,
  160            'port': self.port,
  161            'port_override': self.port_override,
  162            'remote_identity_group_id': self.remote_identity_group_id,
  163            'remote_identity_healthcheck_username':
  164            self.remote_identity_healthcheck_username,
  165            'secret_store_id': self.secret_store_id,
  166            'tags': self.tags,
  167        }
  168
  169    @classmethod
  170    def from_dict(cls, d):
  171        return cls(
  172            bind_interface=d.get('bind_interface'),
  173            certificate_authority=d.get('certificate_authority'),
  174            client_certificate=d.get('client_certificate'),
  175            client_key=d.get('client_key'),
  176            egress_filter=d.get('egress_filter'),
  177            healthcheck_namespace=d.get('healthcheck_namespace'),
  178            healthy=d.get('healthy'),
  179            hostname=d.get('hostname'),
  180            id=d.get('id'),
  181            name=d.get('name'),
  182            port=d.get('port'),
  183            port_override=d.get('port_override'),
  184            remote_identity_group_id=d.get('remote_identity_group_id'),
  185            remote_identity_healthcheck_username=d.get(
  186                'remote_identity_healthcheck_username'),
  187            secret_store_id=d.get('secret_store_id'),
  188            tags=d.get('tags'),
  189        )
  190
  191
  192class AKSBasicAuth:
  193    '''
  194
  195    '''
  196    __slots__ = [
  197        'bind_interface',
  198        'egress_filter',
  199        'healthcheck_namespace',
  200        'healthy',
  201        'hostname',
  202        'id',
  203        'name',
  204        'password',
  205        'port',
  206        'port_override',
  207        'secret_store_id',
  208        'tags',
  209        'username',
  210    ]
  211
  212    def __init__(
  213        self,
  214        bind_interface=None,
  215        egress_filter=None,
  216        healthcheck_namespace=None,
  217        healthy=None,
  218        hostname=None,
  219        id=None,
  220        name=None,
  221        password=None,
  222        port=None,
  223        port_override=None,
  224        secret_store_id=None,
  225        tags=None,
  226        username=None,
  227    ):
  228        self.bind_interface = bind_interface if bind_interface is not None else ''
  229        '''
  230         Bind interface
  231        '''
  232        self.egress_filter = egress_filter if egress_filter is not None else ''
  233        '''
  234         A filter applied to the routing logic to pin datasource to nodes.
  235        '''
  236        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  237        '''
  238         The path used to check the health of your connection.  Defaults to `default`.
  239        '''
  240        self.healthy = healthy if healthy is not None else False
  241        '''
  242         True if the datasource is reachable and the credentials are valid.
  243        '''
  244        self.hostname = hostname if hostname is not None else ''
  245        '''
  246
  247        '''
  248        self.id = id if id is not None else ''
  249        '''
  250         Unique identifier of the Resource.
  251        '''
  252        self.name = name if name is not None else ''
  253        '''
  254         Unique human-readable name of the Resource.
  255        '''
  256        self.password = password if password is not None else ''
  257        '''
  258
  259        '''
  260        self.port = port if port is not None else 0
  261        '''
  262
  263        '''
  264        self.port_override = port_override if port_override is not None else 0
  265        '''
  266
  267        '''
  268        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  269        '''
  270         ID of the secret store containing credentials for this resource, if any.
  271        '''
  272        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  273        '''
  274         Tags is a map of key, value pairs.
  275        '''
  276        self.username = username if username is not None else ''
  277        '''
  278
  279        '''
  280
  281    def __repr__(self):
  282        return '<sdm.AKSBasicAuth ' + \
  283            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  284            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  285            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  286            'healthy: ' + repr(self.healthy) + ' ' +\
  287            'hostname: ' + repr(self.hostname) + ' ' +\
  288            'id: ' + repr(self.id) + ' ' +\
  289            'name: ' + repr(self.name) + ' ' +\
  290            'password: ' + repr(self.password) + ' ' +\
  291            'port: ' + repr(self.port) + ' ' +\
  292            'port_override: ' + repr(self.port_override) + ' ' +\
  293            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  294            'tags: ' + repr(self.tags) + ' ' +\
  295            'username: ' + repr(self.username) + ' ' +\
  296            '>'
  297
  298    def to_dict(self):
  299        return {
  300            'bind_interface': self.bind_interface,
  301            'egress_filter': self.egress_filter,
  302            'healthcheck_namespace': self.healthcheck_namespace,
  303            'healthy': self.healthy,
  304            'hostname': self.hostname,
  305            'id': self.id,
  306            'name': self.name,
  307            'password': self.password,
  308            'port': self.port,
  309            'port_override': self.port_override,
  310            'secret_store_id': self.secret_store_id,
  311            'tags': self.tags,
  312            'username': self.username,
  313        }
  314
  315    @classmethod
  316    def from_dict(cls, d):
  317        return cls(
  318            bind_interface=d.get('bind_interface'),
  319            egress_filter=d.get('egress_filter'),
  320            healthcheck_namespace=d.get('healthcheck_namespace'),
  321            healthy=d.get('healthy'),
  322            hostname=d.get('hostname'),
  323            id=d.get('id'),
  324            name=d.get('name'),
  325            password=d.get('password'),
  326            port=d.get('port'),
  327            port_override=d.get('port_override'),
  328            secret_store_id=d.get('secret_store_id'),
  329            tags=d.get('tags'),
  330            username=d.get('username'),
  331        )
  332
  333
  334class AKSServiceAccount:
  335    '''
  336
  337    '''
  338    __slots__ = [
  339        'bind_interface',
  340        'egress_filter',
  341        'healthcheck_namespace',
  342        'healthy',
  343        'hostname',
  344        'id',
  345        'name',
  346        'port',
  347        'port_override',
  348        'remote_identity_group_id',
  349        'remote_identity_healthcheck_username',
  350        'secret_store_id',
  351        'tags',
  352        'token',
  353    ]
  354
  355    def __init__(
  356        self,
  357        bind_interface=None,
  358        egress_filter=None,
  359        healthcheck_namespace=None,
  360        healthy=None,
  361        hostname=None,
  362        id=None,
  363        name=None,
  364        port=None,
  365        port_override=None,
  366        remote_identity_group_id=None,
  367        remote_identity_healthcheck_username=None,
  368        secret_store_id=None,
  369        tags=None,
  370        token=None,
  371    ):
  372        self.bind_interface = bind_interface if bind_interface is not None else ''
  373        '''
  374         Bind interface
  375        '''
  376        self.egress_filter = egress_filter if egress_filter is not None else ''
  377        '''
  378         A filter applied to the routing logic to pin datasource to nodes.
  379        '''
  380        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  381        '''
  382         The path used to check the health of your connection.  Defaults to `default`.
  383        '''
  384        self.healthy = healthy if healthy is not None else False
  385        '''
  386         True if the datasource is reachable and the credentials are valid.
  387        '''
  388        self.hostname = hostname if hostname is not None else ''
  389        '''
  390
  391        '''
  392        self.id = id if id is not None else ''
  393        '''
  394         Unique identifier of the Resource.
  395        '''
  396        self.name = name if name is not None else ''
  397        '''
  398         Unique human-readable name of the Resource.
  399        '''
  400        self.port = port if port is not None else 0
  401        '''
  402
  403        '''
  404        self.port_override = port_override if port_override is not None else 0
  405        '''
  406
  407        '''
  408        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  409        '''
  410
  411        '''
  412        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  413        '''
  414
  415        '''
  416        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  417        '''
  418         ID of the secret store containing credentials for this resource, if any.
  419        '''
  420        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  421        '''
  422         Tags is a map of key, value pairs.
  423        '''
  424        self.token = token if token is not None else ''
  425        '''
  426
  427        '''
  428
  429    def __repr__(self):
  430        return '<sdm.AKSServiceAccount ' + \
  431            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  432            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  433            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  434            'healthy: ' + repr(self.healthy) + ' ' +\
  435            'hostname: ' + repr(self.hostname) + ' ' +\
  436            'id: ' + repr(self.id) + ' ' +\
  437            'name: ' + repr(self.name) + ' ' +\
  438            'port: ' + repr(self.port) + ' ' +\
  439            'port_override: ' + repr(self.port_override) + ' ' +\
  440            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  441            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  442            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  443            'tags: ' + repr(self.tags) + ' ' +\
  444            'token: ' + repr(self.token) + ' ' +\
  445            '>'
  446
  447    def to_dict(self):
  448        return {
  449            'bind_interface': self.bind_interface,
  450            'egress_filter': self.egress_filter,
  451            'healthcheck_namespace': self.healthcheck_namespace,
  452            'healthy': self.healthy,
  453            'hostname': self.hostname,
  454            'id': self.id,
  455            'name': self.name,
  456            'port': self.port,
  457            'port_override': self.port_override,
  458            'remote_identity_group_id': self.remote_identity_group_id,
  459            'remote_identity_healthcheck_username':
  460            self.remote_identity_healthcheck_username,
  461            'secret_store_id': self.secret_store_id,
  462            'tags': self.tags,
  463            'token': self.token,
  464        }
  465
  466    @classmethod
  467    def from_dict(cls, d):
  468        return cls(
  469            bind_interface=d.get('bind_interface'),
  470            egress_filter=d.get('egress_filter'),
  471            healthcheck_namespace=d.get('healthcheck_namespace'),
  472            healthy=d.get('healthy'),
  473            hostname=d.get('hostname'),
  474            id=d.get('id'),
  475            name=d.get('name'),
  476            port=d.get('port'),
  477            port_override=d.get('port_override'),
  478            remote_identity_group_id=d.get('remote_identity_group_id'),
  479            remote_identity_healthcheck_username=d.get(
  480                'remote_identity_healthcheck_username'),
  481            secret_store_id=d.get('secret_store_id'),
  482            tags=d.get('tags'),
  483            token=d.get('token'),
  484        )
  485
  486
  487class AKSServiceAccountUserImpersonation:
  488    '''
  489
  490    '''
  491    __slots__ = [
  492        'bind_interface',
  493        'egress_filter',
  494        'healthcheck_namespace',
  495        'healthy',
  496        'hostname',
  497        'id',
  498        'name',
  499        'port',
  500        'port_override',
  501        'secret_store_id',
  502        'tags',
  503        'token',
  504    ]
  505
  506    def __init__(
  507        self,
  508        bind_interface=None,
  509        egress_filter=None,
  510        healthcheck_namespace=None,
  511        healthy=None,
  512        hostname=None,
  513        id=None,
  514        name=None,
  515        port=None,
  516        port_override=None,
  517        secret_store_id=None,
  518        tags=None,
  519        token=None,
  520    ):
  521        self.bind_interface = bind_interface if bind_interface is not None else ''
  522        '''
  523         Bind interface
  524        '''
  525        self.egress_filter = egress_filter if egress_filter is not None else ''
  526        '''
  527         A filter applied to the routing logic to pin datasource to nodes.
  528        '''
  529        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  530        '''
  531         The path used to check the health of your connection.  Defaults to `default`.
  532        '''
  533        self.healthy = healthy if healthy is not None else False
  534        '''
  535         True if the datasource is reachable and the credentials are valid.
  536        '''
  537        self.hostname = hostname if hostname is not None else ''
  538        '''
  539
  540        '''
  541        self.id = id if id is not None else ''
  542        '''
  543         Unique identifier of the Resource.
  544        '''
  545        self.name = name if name is not None else ''
  546        '''
  547         Unique human-readable name of the Resource.
  548        '''
  549        self.port = port if port is not None else 0
  550        '''
  551
  552        '''
  553        self.port_override = port_override if port_override is not None else 0
  554        '''
  555
  556        '''
  557        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  558        '''
  559         ID of the secret store containing credentials for this resource, if any.
  560        '''
  561        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  562        '''
  563         Tags is a map of key, value pairs.
  564        '''
  565        self.token = token if token is not None else ''
  566        '''
  567
  568        '''
  569
  570    def __repr__(self):
  571        return '<sdm.AKSServiceAccountUserImpersonation ' + \
  572            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  573            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  574            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  575            'healthy: ' + repr(self.healthy) + ' ' +\
  576            'hostname: ' + repr(self.hostname) + ' ' +\
  577            'id: ' + repr(self.id) + ' ' +\
  578            'name: ' + repr(self.name) + ' ' +\
  579            'port: ' + repr(self.port) + ' ' +\
  580            'port_override: ' + repr(self.port_override) + ' ' +\
  581            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  582            'tags: ' + repr(self.tags) + ' ' +\
  583            'token: ' + repr(self.token) + ' ' +\
  584            '>'
  585
  586    def to_dict(self):
  587        return {
  588            'bind_interface': self.bind_interface,
  589            'egress_filter': self.egress_filter,
  590            'healthcheck_namespace': self.healthcheck_namespace,
  591            'healthy': self.healthy,
  592            'hostname': self.hostname,
  593            'id': self.id,
  594            'name': self.name,
  595            'port': self.port,
  596            'port_override': self.port_override,
  597            'secret_store_id': self.secret_store_id,
  598            'tags': self.tags,
  599            'token': self.token,
  600        }
  601
  602    @classmethod
  603    def from_dict(cls, d):
  604        return cls(
  605            bind_interface=d.get('bind_interface'),
  606            egress_filter=d.get('egress_filter'),
  607            healthcheck_namespace=d.get('healthcheck_namespace'),
  608            healthy=d.get('healthy'),
  609            hostname=d.get('hostname'),
  610            id=d.get('id'),
  611            name=d.get('name'),
  612            port=d.get('port'),
  613            port_override=d.get('port_override'),
  614            secret_store_id=d.get('secret_store_id'),
  615            tags=d.get('tags'),
  616            token=d.get('token'),
  617        )
  618
  619
  620class AKSUserImpersonation:
  621    '''
  622
  623    '''
  624    __slots__ = [
  625        'bind_interface',
  626        'certificate_authority',
  627        'client_certificate',
  628        'client_key',
  629        'egress_filter',
  630        'healthcheck_namespace',
  631        'healthy',
  632        'hostname',
  633        'id',
  634        'name',
  635        'port',
  636        'port_override',
  637        'secret_store_id',
  638        'tags',
  639    ]
  640
  641    def __init__(
  642        self,
  643        bind_interface=None,
  644        certificate_authority=None,
  645        client_certificate=None,
  646        client_key=None,
  647        egress_filter=None,
  648        healthcheck_namespace=None,
  649        healthy=None,
  650        hostname=None,
  651        id=None,
  652        name=None,
  653        port=None,
  654        port_override=None,
  655        secret_store_id=None,
  656        tags=None,
  657    ):
  658        self.bind_interface = bind_interface if bind_interface is not None else ''
  659        '''
  660         Bind interface
  661        '''
  662        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
  663        '''
  664
  665        '''
  666        self.client_certificate = client_certificate if client_certificate is not None else ''
  667        '''
  668
  669        '''
  670        self.client_key = client_key if client_key is not None else ''
  671        '''
  672
  673        '''
  674        self.egress_filter = egress_filter if egress_filter is not None else ''
  675        '''
  676         A filter applied to the routing logic to pin datasource to nodes.
  677        '''
  678        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  679        '''
  680         The path used to check the health of your connection.  Defaults to `default`.
  681        '''
  682        self.healthy = healthy if healthy is not None else False
  683        '''
  684         True if the datasource is reachable and the credentials are valid.
  685        '''
  686        self.hostname = hostname if hostname is not None else ''
  687        '''
  688
  689        '''
  690        self.id = id if id is not None else ''
  691        '''
  692         Unique identifier of the Resource.
  693        '''
  694        self.name = name if name is not None else ''
  695        '''
  696         Unique human-readable name of the Resource.
  697        '''
  698        self.port = port if port is not None else 0
  699        '''
  700
  701        '''
  702        self.port_override = port_override if port_override is not None else 0
  703        '''
  704
  705        '''
  706        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  707        '''
  708         ID of the secret store containing credentials for this resource, if any.
  709        '''
  710        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  711        '''
  712         Tags is a map of key, value pairs.
  713        '''
  714
  715    def __repr__(self):
  716        return '<sdm.AKSUserImpersonation ' + \
  717            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  718            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  719            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  720            'client_key: ' + repr(self.client_key) + ' ' +\
  721            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  722            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  723            'healthy: ' + repr(self.healthy) + ' ' +\
  724            'hostname: ' + repr(self.hostname) + ' ' +\
  725            'id: ' + repr(self.id) + ' ' +\
  726            'name: ' + repr(self.name) + ' ' +\
  727            'port: ' + repr(self.port) + ' ' +\
  728            'port_override: ' + repr(self.port_override) + ' ' +\
  729            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  730            'tags: ' + repr(self.tags) + ' ' +\
  731            '>'
  732
  733    def to_dict(self):
  734        return {
  735            'bind_interface': self.bind_interface,
  736            'certificate_authority': self.certificate_authority,
  737            'client_certificate': self.client_certificate,
  738            'client_key': self.client_key,
  739            'egress_filter': self.egress_filter,
  740            'healthcheck_namespace': self.healthcheck_namespace,
  741            'healthy': self.healthy,
  742            'hostname': self.hostname,
  743            'id': self.id,
  744            'name': self.name,
  745            'port': self.port,
  746            'port_override': self.port_override,
  747            'secret_store_id': self.secret_store_id,
  748            'tags': self.tags,
  749        }
  750
  751    @classmethod
  752    def from_dict(cls, d):
  753        return cls(
  754            bind_interface=d.get('bind_interface'),
  755            certificate_authority=d.get('certificate_authority'),
  756            client_certificate=d.get('client_certificate'),
  757            client_key=d.get('client_key'),
  758            egress_filter=d.get('egress_filter'),
  759            healthcheck_namespace=d.get('healthcheck_namespace'),
  760            healthy=d.get('healthy'),
  761            hostname=d.get('hostname'),
  762            id=d.get('id'),
  763            name=d.get('name'),
  764            port=d.get('port'),
  765            port_override=d.get('port_override'),
  766            secret_store_id=d.get('secret_store_id'),
  767            tags=d.get('tags'),
  768        )
  769
  770
  771class AWS:
  772    '''
  773
  774    '''
  775    __slots__ = [
  776        'access_key',
  777        'bind_interface',
  778        'egress_filter',
  779        'healthcheck_region',
  780        'healthy',
  781        'id',
  782        'name',
  783        'role_arn',
  784        'role_external_id',
  785        'secret_access_key',
  786        'secret_store_id',
  787        'tags',
  788    ]
  789
  790    def __init__(
  791        self,
  792        access_key=None,
  793        bind_interface=None,
  794        egress_filter=None,
  795        healthcheck_region=None,
  796        healthy=None,
  797        id=None,
  798        name=None,
  799        role_arn=None,
  800        role_external_id=None,
  801        secret_access_key=None,
  802        secret_store_id=None,
  803        tags=None,
  804    ):
  805        self.access_key = access_key if access_key is not None else ''
  806        '''
  807
  808        '''
  809        self.bind_interface = bind_interface if bind_interface is not None else ''
  810        '''
  811         Bind interface
  812        '''
  813        self.egress_filter = egress_filter if egress_filter is not None else ''
  814        '''
  815         A filter applied to the routing logic to pin datasource to nodes.
  816        '''
  817        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
  818        '''
  819
  820        '''
  821        self.healthy = healthy if healthy is not None else False
  822        '''
  823         True if the datasource is reachable and the credentials are valid.
  824        '''
  825        self.id = id if id is not None else ''
  826        '''
  827         Unique identifier of the Resource.
  828        '''
  829        self.name = name if name is not None else ''
  830        '''
  831         Unique human-readable name of the Resource.
  832        '''
  833        self.role_arn = role_arn if role_arn is not None else ''
  834        '''
  835
  836        '''
  837        self.role_external_id = role_external_id if role_external_id is not None else ''
  838        '''
  839
  840        '''
  841        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
  842        '''
  843
  844        '''
  845        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  846        '''
  847         ID of the secret store containing credentials for this resource, if any.
  848        '''
  849        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  850        '''
  851         Tags is a map of key, value pairs.
  852        '''
  853
  854    def __repr__(self):
  855        return '<sdm.AWS ' + \
  856            'access_key: ' + repr(self.access_key) + ' ' +\
  857            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  858            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  859            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
  860            'healthy: ' + repr(self.healthy) + ' ' +\
  861            'id: ' + repr(self.id) + ' ' +\
  862            'name: ' + repr(self.name) + ' ' +\
  863            'role_arn: ' + repr(self.role_arn) + ' ' +\
  864            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
  865            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
  866            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  867            'tags: ' + repr(self.tags) + ' ' +\
  868            '>'
  869
  870    def to_dict(self):
  871        return {
  872            'access_key': self.access_key,
  873            'bind_interface': self.bind_interface,
  874            'egress_filter': self.egress_filter,
  875            'healthcheck_region': self.healthcheck_region,
  876            'healthy': self.healthy,
  877            'id': self.id,
  878            'name': self.name,
  879            'role_arn': self.role_arn,
  880            'role_external_id': self.role_external_id,
  881            'secret_access_key': self.secret_access_key,
  882            'secret_store_id': self.secret_store_id,
  883            'tags': self.tags,
  884        }
  885
  886    @classmethod
  887    def from_dict(cls, d):
  888        return cls(
  889            access_key=d.get('access_key'),
  890            bind_interface=d.get('bind_interface'),
  891            egress_filter=d.get('egress_filter'),
  892            healthcheck_region=d.get('healthcheck_region'),
  893            healthy=d.get('healthy'),
  894            id=d.get('id'),
  895            name=d.get('name'),
  896            role_arn=d.get('role_arn'),
  897            role_external_id=d.get('role_external_id'),
  898            secret_access_key=d.get('secret_access_key'),
  899            secret_store_id=d.get('secret_store_id'),
  900            tags=d.get('tags'),
  901        )
  902
  903
  904class AWSStore:
  905    '''
  906
  907    '''
  908    __slots__ = [
  909        'id',
  910        'name',
  911        'region',
  912        'tags',
  913    ]
  914
  915    def __init__(
  916        self,
  917        id=None,
  918        name=None,
  919        region=None,
  920        tags=None,
  921    ):
  922        self.id = id if id is not None else ''
  923        '''
  924         Unique identifier of the SecretStore.
  925        '''
  926        self.name = name if name is not None else ''
  927        '''
  928         Unique human-readable name of the SecretStore.
  929        '''
  930        self.region = region if region is not None else ''
  931        '''
  932
  933        '''
  934        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  935        '''
  936         Tags is a map of key, value pairs.
  937        '''
  938
  939    def __repr__(self):
  940        return '<sdm.AWSStore ' + \
  941            'id: ' + repr(self.id) + ' ' +\
  942            'name: ' + repr(self.name) + ' ' +\
  943            'region: ' + repr(self.region) + ' ' +\
  944            'tags: ' + repr(self.tags) + ' ' +\
  945            '>'
  946
  947    def to_dict(self):
  948        return {
  949            'id': self.id,
  950            'name': self.name,
  951            'region': self.region,
  952            'tags': self.tags,
  953        }
  954
  955    @classmethod
  956    def from_dict(cls, d):
  957        return cls(
  958            id=d.get('id'),
  959            name=d.get('name'),
  960            region=d.get('region'),
  961            tags=d.get('tags'),
  962        )
  963
  964
  965class AccountAttachment:
  966    '''
  967     AccountAttachments assign an account to a role.
  968    '''
  969    __slots__ = [
  970        'account_id',
  971        'id',
  972        'role_id',
  973    ]
  974
  975    def __init__(
  976        self,
  977        account_id=None,
  978        id=None,
  979        role_id=None,
  980    ):
  981        self.account_id = account_id if account_id is not None else ''
  982        '''
  983         The id of the account of this AccountAttachment.
  984        '''
  985        self.id = id if id is not None else ''
  986        '''
  987         Unique identifier of the AccountAttachment.
  988        '''
  989        self.role_id = role_id if role_id is not None else ''
  990        '''
  991         The id of the attached role of this AccountAttachment.
  992        '''
  993
  994    def __repr__(self):
  995        return '<sdm.AccountAttachment ' + \
  996            'account_id: ' + repr(self.account_id) + ' ' +\
  997            'id: ' + repr(self.id) + ' ' +\
  998            'role_id: ' + repr(self.role_id) + ' ' +\
  999            '>'
 1000
 1001    def to_dict(self):
 1002        return {
 1003            'account_id': self.account_id,
 1004            'id': self.id,
 1005            'role_id': self.role_id,
 1006        }
 1007
 1008    @classmethod
 1009    def from_dict(cls, d):
 1010        return cls(
 1011            account_id=d.get('account_id'),
 1012            id=d.get('id'),
 1013            role_id=d.get('role_id'),
 1014        )
 1015
 1016
 1017class AccountAttachmentCreateResponse:
 1018    '''
 1019     AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
 1020    '''
 1021    __slots__ = [
 1022        'account_attachment',
 1023        'meta',
 1024        'rate_limit',
 1025    ]
 1026
 1027    def __init__(
 1028        self,
 1029        account_attachment=None,
 1030        meta=None,
 1031        rate_limit=None,
 1032    ):
 1033        self.account_attachment = account_attachment if account_attachment is not None else None
 1034        '''
 1035         The created AccountAttachment.
 1036        '''
 1037        self.meta = meta if meta is not None else None
 1038        '''
 1039         Reserved for future use.
 1040        '''
 1041        self.rate_limit = rate_limit if rate_limit is not None else None
 1042        '''
 1043         Rate limit information.
 1044        '''
 1045
 1046    def __repr__(self):
 1047        return '<sdm.AccountAttachmentCreateResponse ' + \
 1048            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1049            'meta: ' + repr(self.meta) + ' ' +\
 1050            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1051            '>'
 1052
 1053    def to_dict(self):
 1054        return {
 1055            'account_attachment': self.account_attachment,
 1056            'meta': self.meta,
 1057            'rate_limit': self.rate_limit,
 1058        }
 1059
 1060    @classmethod
 1061    def from_dict(cls, d):
 1062        return cls(
 1063            account_attachment=d.get('account_attachment'),
 1064            meta=d.get('meta'),
 1065            rate_limit=d.get('rate_limit'),
 1066        )
 1067
 1068
 1069class AccountAttachmentDeleteResponse:
 1070    '''
 1071     AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
 1072    '''
 1073    __slots__ = [
 1074        'meta',
 1075        'rate_limit',
 1076    ]
 1077
 1078    def __init__(
 1079        self,
 1080        meta=None,
 1081        rate_limit=None,
 1082    ):
 1083        self.meta = meta if meta is not None else None
 1084        '''
 1085         Reserved for future use.
 1086        '''
 1087        self.rate_limit = rate_limit if rate_limit is not None else None
 1088        '''
 1089         Rate limit information.
 1090        '''
 1091
 1092    def __repr__(self):
 1093        return '<sdm.AccountAttachmentDeleteResponse ' + \
 1094            'meta: ' + repr(self.meta) + ' ' +\
 1095            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1096            '>'
 1097
 1098    def to_dict(self):
 1099        return {
 1100            'meta': self.meta,
 1101            'rate_limit': self.rate_limit,
 1102        }
 1103
 1104    @classmethod
 1105    def from_dict(cls, d):
 1106        return cls(
 1107            meta=d.get('meta'),
 1108            rate_limit=d.get('rate_limit'),
 1109        )
 1110
 1111
 1112class AccountAttachmentGetResponse:
 1113    '''
 1114     AccountAttachmentGetResponse returns a requested AccountAttachment.
 1115    '''
 1116    __slots__ = [
 1117        'account_attachment',
 1118        'meta',
 1119        'rate_limit',
 1120    ]
 1121
 1122    def __init__(
 1123        self,
 1124        account_attachment=None,
 1125        meta=None,
 1126        rate_limit=None,
 1127    ):
 1128        self.account_attachment = account_attachment if account_attachment is not None else None
 1129        '''
 1130         The requested AccountAttachment.
 1131        '''
 1132        self.meta = meta if meta is not None else None
 1133        '''
 1134         Reserved for future use.
 1135        '''
 1136        self.rate_limit = rate_limit if rate_limit is not None else None
 1137        '''
 1138         Rate limit information.
 1139        '''
 1140
 1141    def __repr__(self):
 1142        return '<sdm.AccountAttachmentGetResponse ' + \
 1143            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1144            'meta: ' + repr(self.meta) + ' ' +\
 1145            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1146            '>'
 1147
 1148    def to_dict(self):
 1149        return {
 1150            'account_attachment': self.account_attachment,
 1151            'meta': self.meta,
 1152            'rate_limit': self.rate_limit,
 1153        }
 1154
 1155    @classmethod
 1156    def from_dict(cls, d):
 1157        return cls(
 1158            account_attachment=d.get('account_attachment'),
 1159            meta=d.get('meta'),
 1160            rate_limit=d.get('rate_limit'),
 1161        )
 1162
 1163
 1164class AccountCreateResponse:
 1165    '''
 1166     AccountCreateResponse reports how the Accounts were created in the system.
 1167    '''
 1168    __slots__ = [
 1169        'account',
 1170        'meta',
 1171        'rate_limit',
 1172        'token',
 1173    ]
 1174
 1175    def __init__(
 1176        self,
 1177        account=None,
 1178        meta=None,
 1179        rate_limit=None,
 1180        token=None,
 1181    ):
 1182        self.account = account if account is not None else None
 1183        '''
 1184         The created Account.
 1185        '''
 1186        self.meta = meta if meta is not None else None
 1187        '''
 1188         Reserved for future use.
 1189        '''
 1190        self.rate_limit = rate_limit if rate_limit is not None else None
 1191        '''
 1192         Rate limit information.
 1193        '''
 1194        self.token = token if token is not None else ''
 1195        '''
 1196         The auth token generated for the Account. The Account will use this token to
 1197         authenticate with the strongDM API.
 1198        '''
 1199
 1200    def __repr__(self):
 1201        return '<sdm.AccountCreateResponse ' + \
 1202            'account: ' + repr(self.account) + ' ' +\
 1203            'meta: ' + repr(self.meta) + ' ' +\
 1204            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1205            'token: ' + repr(self.token) + ' ' +\
 1206            '>'
 1207
 1208    def to_dict(self):
 1209        return {
 1210            'account': self.account,
 1211            'meta': self.meta,
 1212            'rate_limit': self.rate_limit,
 1213            'token': self.token,
 1214        }
 1215
 1216    @classmethod
 1217    def from_dict(cls, d):
 1218        return cls(
 1219            account=d.get('account'),
 1220            meta=d.get('meta'),
 1221            rate_limit=d.get('rate_limit'),
 1222            token=d.get('token'),
 1223        )
 1224
 1225
 1226class AccountDeleteResponse:
 1227    '''
 1228     AccountDeleteResponse returns information about a Account that was deleted.
 1229    '''
 1230    __slots__ = [
 1231        'meta',
 1232        'rate_limit',
 1233    ]
 1234
 1235    def __init__(
 1236        self,
 1237        meta=None,
 1238        rate_limit=None,
 1239    ):
 1240        self.meta = meta if meta is not None else None
 1241        '''
 1242         Reserved for future use.
 1243        '''
 1244        self.rate_limit = rate_limit if rate_limit is not None else None
 1245        '''
 1246         Rate limit information.
 1247        '''
 1248
 1249    def __repr__(self):
 1250        return '<sdm.AccountDeleteResponse ' + \
 1251            'meta: ' + repr(self.meta) + ' ' +\
 1252            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1253            '>'
 1254
 1255    def to_dict(self):
 1256        return {
 1257            'meta': self.meta,
 1258            'rate_limit': self.rate_limit,
 1259        }
 1260
 1261    @classmethod
 1262    def from_dict(cls, d):
 1263        return cls(
 1264            meta=d.get('meta'),
 1265            rate_limit=d.get('rate_limit'),
 1266        )
 1267
 1268
 1269class AccountGetResponse:
 1270    '''
 1271     AccountGetResponse returns a requested Account.
 1272    '''
 1273    __slots__ = [
 1274        'account',
 1275        'meta',
 1276        'rate_limit',
 1277    ]
 1278
 1279    def __init__(
 1280        self,
 1281        account=None,
 1282        meta=None,
 1283        rate_limit=None,
 1284    ):
 1285        self.account = account if account is not None else None
 1286        '''
 1287         The requested Account.
 1288        '''
 1289        self.meta = meta if meta is not None else None
 1290        '''
 1291         Reserved for future use.
 1292        '''
 1293        self.rate_limit = rate_limit if rate_limit is not None else None
 1294        '''
 1295         Rate limit information.
 1296        '''
 1297
 1298    def __repr__(self):
 1299        return '<sdm.AccountGetResponse ' + \
 1300            'account: ' + repr(self.account) + ' ' +\
 1301            'meta: ' + repr(self.meta) + ' ' +\
 1302            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1303            '>'
 1304
 1305    def to_dict(self):
 1306        return {
 1307            'account': self.account,
 1308            'meta': self.meta,
 1309            'rate_limit': self.rate_limit,
 1310        }
 1311
 1312    @classmethod
 1313    def from_dict(cls, d):
 1314        return cls(
 1315            account=d.get('account'),
 1316            meta=d.get('meta'),
 1317            rate_limit=d.get('rate_limit'),
 1318        )
 1319
 1320
 1321class AccountGrant:
 1322    '''
 1323     AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
 1324    '''
 1325    __slots__ = [
 1326        'account_id',
 1327        'id',
 1328        'resource_id',
 1329        'start_from',
 1330        'valid_until',
 1331    ]
 1332
 1333    def __init__(
 1334        self,
 1335        account_id=None,
 1336        id=None,
 1337        resource_id=None,
 1338        start_from=None,
 1339        valid_until=None,
 1340    ):
 1341        self.account_id = account_id if account_id is not None else ''
 1342        '''
 1343         The account id of this AccountGrant.
 1344        '''
 1345        self.id = id if id is not None else ''
 1346        '''
 1347         Unique identifier of the AccountGrant.
 1348        '''
 1349        self.resource_id = resource_id if resource_id is not None else ''
 1350        '''
 1351         The resource id of this AccountGrant.
 1352        '''
 1353        self.start_from = start_from if start_from is not None else None
 1354        '''
 1355         The timestamp when the resource will be granted. Optional. Both start_at
 1356         and end_at must be defined together, or not defined at all.
 1357        '''
 1358        self.valid_until = valid_until if valid_until is not None else None
 1359        '''
 1360         The timestamp when the resource grant will expire. Optional. Both
 1361         start_at and end_at must be defined together, or not defined at all.
 1362        '''
 1363
 1364    def __repr__(self):
 1365        return '<sdm.AccountGrant ' + \
 1366            'account_id: ' + repr(self.account_id) + ' ' +\
 1367            'id: ' + repr(self.id) + ' ' +\
 1368            'resource_id: ' + repr(self.resource_id) + ' ' +\
 1369            'start_from: ' + repr(self.start_from) + ' ' +\
 1370            'valid_until: ' + repr(self.valid_until) + ' ' +\
 1371            '>'
 1372
 1373    def to_dict(self):
 1374        return {
 1375            'account_id': self.account_id,
 1376            'id': self.id,
 1377            'resource_id': self.resource_id,
 1378            'start_from': self.start_from,
 1379            'valid_until': self.valid_until,
 1380        }
 1381
 1382    @classmethod
 1383    def from_dict(cls, d):
 1384        return cls(
 1385            account_id=d.get('account_id'),
 1386            id=d.get('id'),
 1387            resource_id=d.get('resource_id'),
 1388            start_from=d.get('start_from'),
 1389            valid_until=d.get('valid_until'),
 1390        )
 1391
 1392
 1393class AccountGrantCreateResponse:
 1394    '''
 1395     AccountGrantCreateResponse reports how the AccountGrants were created in the system.
 1396    '''
 1397    __slots__ = [
 1398        'account_grant',
 1399        'meta',
 1400        'rate_limit',
 1401    ]
 1402
 1403    def __init__(
 1404        self,
 1405        account_grant=None,
 1406        meta=None,
 1407        rate_limit=None,
 1408    ):
 1409        self.account_grant = account_grant if account_grant is not None else None
 1410        '''
 1411         The created AccountGrant.
 1412        '''
 1413        self.meta = meta if meta is not None else None
 1414        '''
 1415         Reserved for future use.
 1416        '''
 1417        self.rate_limit = rate_limit if rate_limit is not None else None
 1418        '''
 1419         Rate limit information.
 1420        '''
 1421
 1422    def __repr__(self):
 1423        return '<sdm.AccountGrantCreateResponse ' + \
 1424            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1425            'meta: ' + repr(self.meta) + ' ' +\
 1426            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1427            '>'
 1428
 1429    def to_dict(self):
 1430        return {
 1431            'account_grant': self.account_grant,
 1432            'meta': self.meta,
 1433            'rate_limit': self.rate_limit,
 1434        }
 1435
 1436    @classmethod
 1437    def from_dict(cls, d):
 1438        return cls(
 1439            account_grant=d.get('account_grant'),
 1440            meta=d.get('meta'),
 1441            rate_limit=d.get('rate_limit'),
 1442        )
 1443
 1444
 1445class AccountGrantDeleteResponse:
 1446    '''
 1447     AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
 1448    '''
 1449    __slots__ = [
 1450        'meta',
 1451        'rate_limit',
 1452    ]
 1453
 1454    def __init__(
 1455        self,
 1456        meta=None,
 1457        rate_limit=None,
 1458    ):
 1459        self.meta = meta if meta is not None else None
 1460        '''
 1461         Reserved for future use.
 1462        '''
 1463        self.rate_limit = rate_limit if rate_limit is not None else None
 1464        '''
 1465         Rate limit information.
 1466        '''
 1467
 1468    def __repr__(self):
 1469        return '<sdm.AccountGrantDeleteResponse ' + \
 1470            'meta: ' + repr(self.meta) + ' ' +\
 1471            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1472            '>'
 1473
 1474    def to_dict(self):
 1475        return {
 1476            'meta': self.meta,
 1477            'rate_limit': self.rate_limit,
 1478        }
 1479
 1480    @classmethod
 1481    def from_dict(cls, d):
 1482        return cls(
 1483            meta=d.get('meta'),
 1484            rate_limit=d.get('rate_limit'),
 1485        )
 1486
 1487
 1488class AccountGrantGetResponse:
 1489    '''
 1490     AccountGrantGetResponse returns a requested AccountGrant.
 1491    '''
 1492    __slots__ = [
 1493        'account_grant',
 1494        'meta',
 1495        'rate_limit',
 1496    ]
 1497
 1498    def __init__(
 1499        self,
 1500        account_grant=None,
 1501        meta=None,
 1502        rate_limit=None,
 1503    ):
 1504        self.account_grant = account_grant if account_grant is not None else None
 1505        '''
 1506         The requested AccountGrant.
 1507        '''
 1508        self.meta = meta if meta is not None else None
 1509        '''
 1510         Reserved for future use.
 1511        '''
 1512        self.rate_limit = rate_limit if rate_limit is not None else None
 1513        '''
 1514         Rate limit information.
 1515        '''
 1516
 1517    def __repr__(self):
 1518        return '<sdm.AccountGrantGetResponse ' + \
 1519            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1520            'meta: ' + repr(self.meta) + ' ' +\
 1521            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1522            '>'
 1523
 1524    def to_dict(self):
 1525        return {
 1526            'account_grant': self.account_grant,
 1527            'meta': self.meta,
 1528            'rate_limit': self.rate_limit,
 1529        }
 1530
 1531    @classmethod
 1532    def from_dict(cls, d):
 1533        return cls(
 1534            account_grant=d.get('account_grant'),
 1535            meta=d.get('meta'),
 1536            rate_limit=d.get('rate_limit'),
 1537        )
 1538
 1539
 1540class AccountUpdateResponse:
 1541    '''
 1542     AccountUpdateResponse returns the fields of a Account after it has been updated by
 1543     a AccountUpdateRequest.
 1544    '''
 1545    __slots__ = [
 1546        'account',
 1547        'meta',
 1548        'rate_limit',
 1549    ]
 1550
 1551    def __init__(
 1552        self,
 1553        account=None,
 1554        meta=None,
 1555        rate_limit=None,
 1556    ):
 1557        self.account = account if account is not None else None
 1558        '''
 1559         The updated Account.
 1560        '''
 1561        self.meta = meta if meta is not None else None
 1562        '''
 1563         Reserved for future use.
 1564        '''
 1565        self.rate_limit = rate_limit if rate_limit is not None else None
 1566        '''
 1567         Rate limit information.
 1568        '''
 1569
 1570    def __repr__(self):
 1571        return '<sdm.AccountUpdateResponse ' + \
 1572            'account: ' + repr(self.account) + ' ' +\
 1573            'meta: ' + repr(self.meta) + ' ' +\
 1574            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1575            '>'
 1576
 1577    def to_dict(self):
 1578        return {
 1579            'account': self.account,
 1580            'meta': self.meta,
 1581            'rate_limit': self.rate_limit,
 1582        }
 1583
 1584    @classmethod
 1585    def from_dict(cls, d):
 1586        return cls(
 1587            account=d.get('account'),
 1588            meta=d.get('meta'),
 1589            rate_limit=d.get('rate_limit'),
 1590        )
 1591
 1592
 1593class AmazonEKS:
 1594    '''
 1595
 1596    '''
 1597    __slots__ = [
 1598        'access_key',
 1599        'bind_interface',
 1600        'certificate_authority',
 1601        'cluster_name',
 1602        'egress_filter',
 1603        'endpoint',
 1604        'healthcheck_namespace',
 1605        'healthy',
 1606        'id',
 1607        'name',
 1608        'region',
 1609        'remote_identity_group_id',
 1610        'remote_identity_healthcheck_username',
 1611        'role_arn',
 1612        'role_external_id',
 1613        'secret_access_key',
 1614        'secret_store_id',
 1615        'tags',
 1616    ]
 1617
 1618    def __init__(
 1619        self,
 1620        access_key=None,
 1621        bind_interface=None,
 1622        certificate_authority=None,
 1623        cluster_name=None,
 1624        egress_filter=None,
 1625        endpoint=None,
 1626        healthcheck_namespace=None,
 1627        healthy=None,
 1628        id=None,
 1629        name=None,
 1630        region=None,
 1631        remote_identity_group_id=None,
 1632        remote_identity_healthcheck_username=None,
 1633        role_arn=None,
 1634        role_external_id=None,
 1635        secret_access_key=None,
 1636        secret_store_id=None,
 1637        tags=None,
 1638    ):
 1639        self.access_key = access_key if access_key is not None else ''
 1640        '''
 1641
 1642        '''
 1643        self.bind_interface = bind_interface if bind_interface is not None else ''
 1644        '''
 1645         Bind interface
 1646        '''
 1647        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1648        '''
 1649
 1650        '''
 1651        self.cluster_name = cluster_name if cluster_name is not None else ''
 1652        '''
 1653
 1654        '''
 1655        self.egress_filter = egress_filter if egress_filter is not None else ''
 1656        '''
 1657         A filter applied to the routing logic to pin datasource to nodes.
 1658        '''
 1659        self.endpoint = endpoint if endpoint is not None else ''
 1660        '''
 1661
 1662        '''
 1663        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1664        '''
 1665         The path used to check the health of your connection.  Defaults to `default`.
 1666        '''
 1667        self.healthy = healthy if healthy is not None else False
 1668        '''
 1669         True if the datasource is reachable and the credentials are valid.
 1670        '''
 1671        self.id = id if id is not None else ''
 1672        '''
 1673         Unique identifier of the Resource.
 1674        '''
 1675        self.name = name if name is not None else ''
 1676        '''
 1677         Unique human-readable name of the Resource.
 1678        '''
 1679        self.region = region if region is not None else ''
 1680        '''
 1681
 1682        '''
 1683        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 1684        '''
 1685
 1686        '''
 1687        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 1688        '''
 1689
 1690        '''
 1691        self.role_arn = role_arn if role_arn is not None else ''
 1692        '''
 1693
 1694        '''
 1695        self.role_external_id = role_external_id if role_external_id is not None else ''
 1696        '''
 1697
 1698        '''
 1699        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1700        '''
 1701
 1702        '''
 1703        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1704        '''
 1705         ID of the secret store containing credentials for this resource, if any.
 1706        '''
 1707        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1708        '''
 1709         Tags is a map of key, value pairs.
 1710        '''
 1711
 1712    def __repr__(self):
 1713        return '<sdm.AmazonEKS ' + \
 1714            'access_key: ' + repr(self.access_key) + ' ' +\
 1715            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1716            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1717            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1718            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1719            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1720            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1721            'healthy: ' + repr(self.healthy) + ' ' +\
 1722            'id: ' + repr(self.id) + ' ' +\
 1723            'name: ' + repr(self.name) + ' ' +\
 1724            'region: ' + repr(self.region) + ' ' +\
 1725            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 1726            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 1727            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1728            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1729            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1730            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1731            'tags: ' + repr(self.tags) + ' ' +\
 1732            '>'
 1733
 1734    def to_dict(self):
 1735        return {
 1736            'access_key': self.access_key,
 1737            'bind_interface': self.bind_interface,
 1738            'certificate_authority': self.certificate_authority,
 1739            'cluster_name': self.cluster_name,
 1740            'egress_filter': self.egress_filter,
 1741            'endpoint': self.endpoint,
 1742            'healthcheck_namespace': self.healthcheck_namespace,
 1743            'healthy': self.healthy,
 1744            'id': self.id,
 1745            'name': self.name,
 1746            'region': self.region,
 1747            'remote_identity_group_id': self.remote_identity_group_id,
 1748            'remote_identity_healthcheck_username':
 1749            self.remote_identity_healthcheck_username,
 1750            'role_arn': self.role_arn,
 1751            'role_external_id': self.role_external_id,
 1752            'secret_access_key': self.secret_access_key,
 1753            'secret_store_id': self.secret_store_id,
 1754            'tags': self.tags,
 1755        }
 1756
 1757    @classmethod
 1758    def from_dict(cls, d):
 1759        return cls(
 1760            access_key=d.get('access_key'),
 1761            bind_interface=d.get('bind_interface'),
 1762            certificate_authority=d.get('certificate_authority'),
 1763            cluster_name=d.get('cluster_name'),
 1764            egress_filter=d.get('egress_filter'),
 1765            endpoint=d.get('endpoint'),
 1766            healthcheck_namespace=d.get('healthcheck_namespace'),
 1767            healthy=d.get('healthy'),
 1768            id=d.get('id'),
 1769            name=d.get('name'),
 1770            region=d.get('region'),
 1771            remote_identity_group_id=d.get('remote_identity_group_id'),
 1772            remote_identity_healthcheck_username=d.get(
 1773                'remote_identity_healthcheck_username'),
 1774            role_arn=d.get('role_arn'),
 1775            role_external_id=d.get('role_external_id'),
 1776            secret_access_key=d.get('secret_access_key'),
 1777            secret_store_id=d.get('secret_store_id'),
 1778            tags=d.get('tags'),
 1779        )
 1780
 1781
 1782class AmazonEKSUserImpersonation:
 1783    '''
 1784
 1785    '''
 1786    __slots__ = [
 1787        'access_key',
 1788        'bind_interface',
 1789        'certificate_authority',
 1790        'cluster_name',
 1791        'egress_filter',
 1792        'endpoint',
 1793        'healthcheck_namespace',
 1794        'healthy',
 1795        'id',
 1796        'name',
 1797        'region',
 1798        'role_arn',
 1799        'role_external_id',
 1800        'secret_access_key',
 1801        'secret_store_id',
 1802        'tags',
 1803    ]
 1804
 1805    def __init__(
 1806        self,
 1807        access_key=None,
 1808        bind_interface=None,
 1809        certificate_authority=None,
 1810        cluster_name=None,
 1811        egress_filter=None,
 1812        endpoint=None,
 1813        healthcheck_namespace=None,
 1814        healthy=None,
 1815        id=None,
 1816        name=None,
 1817        region=None,
 1818        role_arn=None,
 1819        role_external_id=None,
 1820        secret_access_key=None,
 1821        secret_store_id=None,
 1822        tags=None,
 1823    ):
 1824        self.access_key = access_key if access_key is not None else ''
 1825        '''
 1826
 1827        '''
 1828        self.bind_interface = bind_interface if bind_interface is not None else ''
 1829        '''
 1830         Bind interface
 1831        '''
 1832        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1833        '''
 1834
 1835        '''
 1836        self.cluster_name = cluster_name if cluster_name is not None else ''
 1837        '''
 1838
 1839        '''
 1840        self.egress_filter = egress_filter if egress_filter is not None else ''
 1841        '''
 1842         A filter applied to the routing logic to pin datasource to nodes.
 1843        '''
 1844        self.endpoint = endpoint if endpoint is not None else ''
 1845        '''
 1846
 1847        '''
 1848        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1849        '''
 1850         The path used to check the health of your connection.  Defaults to `default`.
 1851        '''
 1852        self.healthy = healthy if healthy is not None else False
 1853        '''
 1854         True if the datasource is reachable and the credentials are valid.
 1855        '''
 1856        self.id = id if id is not None else ''
 1857        '''
 1858         Unique identifier of the Resource.
 1859        '''
 1860        self.name = name if name is not None else ''
 1861        '''
 1862         Unique human-readable name of the Resource.
 1863        '''
 1864        self.region = region if region is not None else ''
 1865        '''
 1866
 1867        '''
 1868        self.role_arn = role_arn if role_arn is not None else ''
 1869        '''
 1870
 1871        '''
 1872        self.role_external_id = role_external_id if role_external_id is not None else ''
 1873        '''
 1874
 1875        '''
 1876        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1877        '''
 1878
 1879        '''
 1880        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1881        '''
 1882         ID of the secret store containing credentials for this resource, if any.
 1883        '''
 1884        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1885        '''
 1886         Tags is a map of key, value pairs.
 1887        '''
 1888
 1889    def __repr__(self):
 1890        return '<sdm.AmazonEKSUserImpersonation ' + \
 1891            'access_key: ' + repr(self.access_key) + ' ' +\
 1892            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1893            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1894            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1895            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1896            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1897            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1898            'healthy: ' + repr(self.healthy) + ' ' +\
 1899            'id: ' + repr(self.id) + ' ' +\
 1900            'name: ' + repr(self.name) + ' ' +\
 1901            'region: ' + repr(self.region) + ' ' +\
 1902            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1903            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1904            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1905            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1906            'tags: ' + repr(self.tags) + ' ' +\
 1907            '>'
 1908
 1909    def to_dict(self):
 1910        return {
 1911            'access_key': self.access_key,
 1912            'bind_interface': self.bind_interface,
 1913            'certificate_authority': self.certificate_authority,
 1914            'cluster_name': self.cluster_name,
 1915            'egress_filter': self.egress_filter,
 1916            'endpoint': self.endpoint,
 1917            'healthcheck_namespace': self.healthcheck_namespace,
 1918            'healthy': self.healthy,
 1919            'id': self.id,
 1920            'name': self.name,
 1921            'region': self.region,
 1922            'role_arn': self.role_arn,
 1923            'role_external_id': self.role_external_id,
 1924            'secret_access_key': self.secret_access_key,
 1925            'secret_store_id': self.secret_store_id,
 1926            'tags': self.tags,
 1927        }
 1928
 1929    @classmethod
 1930    def from_dict(cls, d):
 1931        return cls(
 1932            access_key=d.get('access_key'),
 1933            bind_interface=d.get('bind_interface'),
 1934            certificate_authority=d.get('certificate_authority'),
 1935            cluster_name=d.get('cluster_name'),
 1936            egress_filter=d.get('egress_filter'),
 1937            endpoint=d.get('endpoint'),
 1938            healthcheck_namespace=d.get('healthcheck_namespace'),
 1939            healthy=d.get('healthy'),
 1940            id=d.get('id'),
 1941            name=d.get('name'),
 1942            region=d.get('region'),
 1943            role_arn=d.get('role_arn'),
 1944            role_external_id=d.get('role_external_id'),
 1945            secret_access_key=d.get('secret_access_key'),
 1946            secret_store_id=d.get('secret_store_id'),
 1947            tags=d.get('tags'),
 1948        )
 1949
 1950
 1951class AmazonES:
 1952    '''
 1953
 1954    '''
 1955    __slots__ = [
 1956        'access_key',
 1957        'bind_interface',
 1958        'egress_filter',
 1959        'endpoint',
 1960        'healthy',
 1961        'id',
 1962        'name',
 1963        'port_override',
 1964        'region',
 1965        'role_arn',
 1966        'role_external_id',
 1967        'secret_access_key',
 1968        'secret_store_id',
 1969        'tags',
 1970    ]
 1971
 1972    def __init__(
 1973        self,
 1974        access_key=None,
 1975        bind_interface=None,
 1976        egress_filter=None,
 1977        endpoint=None,
 1978        healthy=None,
 1979        id=None,
 1980        name=None,
 1981        port_override=None,
 1982        region=None,
 1983        role_arn=None,
 1984        role_external_id=None,
 1985        secret_access_key=None,
 1986        secret_store_id=None,
 1987        tags=None,
 1988    ):
 1989        self.access_key = access_key if access_key is not None else ''
 1990        '''
 1991
 1992        '''
 1993        self.bind_interface = bind_interface if bind_interface is not None else ''
 1994        '''
 1995         Bind interface
 1996        '''
 1997        self.egress_filter = egress_filter if egress_filter is not None else ''
 1998        '''
 1999         A filter applied to the routing logic to pin datasource to nodes.
 2000        '''
 2001        self.endpoint = endpoint if endpoint is not None else ''
 2002        '''
 2003
 2004        '''
 2005        self.healthy = healthy if healthy is not None else False
 2006        '''
 2007         True if the datasource is reachable and the credentials are valid.
 2008        '''
 2009        self.id = id if id is not None else ''
 2010        '''
 2011         Unique identifier of the Resource.
 2012        '''
 2013        self.name = name if name is not None else ''
 2014        '''
 2015         Unique human-readable name of the Resource.
 2016        '''
 2017        self.port_override = port_override if port_override is not None else 0
 2018        '''
 2019
 2020        '''
 2021        self.region = region if region is not None else ''
 2022        '''
 2023
 2024        '''
 2025        self.role_arn = role_arn if role_arn is not None else ''
 2026        '''
 2027
 2028        '''
 2029        self.role_external_id = role_external_id if role_external_id is not None else ''
 2030        '''
 2031
 2032        '''
 2033        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2034        '''
 2035
 2036        '''
 2037        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2038        '''
 2039         ID of the secret store containing credentials for this resource, if any.
 2040        '''
 2041        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2042        '''
 2043         Tags is a map of key, value pairs.
 2044        '''
 2045
 2046    def __repr__(self):
 2047        return '<sdm.AmazonES ' + \
 2048            'access_key: ' + repr(self.access_key) + ' ' +\
 2049            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2050            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2051            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2052            'healthy: ' + repr(self.healthy) + ' ' +\
 2053            'id: ' + repr(self.id) + ' ' +\
 2054            'name: ' + repr(self.name) + ' ' +\
 2055            'port_override: ' + repr(self.port_override) + ' ' +\
 2056            'region: ' + repr(self.region) + ' ' +\
 2057            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2058            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2059            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2060            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2061            'tags: ' + repr(self.tags) + ' ' +\
 2062            '>'
 2063
 2064    def to_dict(self):
 2065        return {
 2066            'access_key': self.access_key,
 2067            'bind_interface': self.bind_interface,
 2068            'egress_filter': self.egress_filter,
 2069            'endpoint': self.endpoint,
 2070            'healthy': self.healthy,
 2071            'id': self.id,
 2072            'name': self.name,
 2073            'port_override': self.port_override,
 2074            'region': self.region,
 2075            'role_arn': self.role_arn,
 2076            'role_external_id': self.role_external_id,
 2077            'secret_access_key': self.secret_access_key,
 2078            'secret_store_id': self.secret_store_id,
 2079            'tags': self.tags,
 2080        }
 2081
 2082    @classmethod
 2083    def from_dict(cls, d):
 2084        return cls(
 2085            access_key=d.get('access_key'),
 2086            bind_interface=d.get('bind_interface'),
 2087            egress_filter=d.get('egress_filter'),
 2088            endpoint=d.get('endpoint'),
 2089            healthy=d.get('healthy'),
 2090            id=d.get('id'),
 2091            name=d.get('name'),
 2092            port_override=d.get('port_override'),
 2093            region=d.get('region'),
 2094            role_arn=d.get('role_arn'),
 2095            role_external_id=d.get('role_external_id'),
 2096            secret_access_key=d.get('secret_access_key'),
 2097            secret_store_id=d.get('secret_store_id'),
 2098            tags=d.get('tags'),
 2099        )
 2100
 2101
 2102class AmazonMQAMQP091:
 2103    '''
 2104
 2105    '''
 2106    __slots__ = [
 2107        'bind_interface',
 2108        'egress_filter',
 2109        'healthy',
 2110        'hostname',
 2111        'id',
 2112        'name',
 2113        'password',
 2114        'port',
 2115        'port_override',
 2116        'secret_store_id',
 2117        'tags',
 2118        'tls_required',
 2119        'username',
 2120    ]
 2121
 2122    def __init__(
 2123        self,
 2124        bind_interface=None,
 2125        egress_filter=None,
 2126        healthy=None,
 2127        hostname=None,
 2128        id=None,
 2129        name=None,
 2130        password=None,
 2131        port=None,
 2132        port_override=None,
 2133        secret_store_id=None,
 2134        tags=None,
 2135        tls_required=None,
 2136        username=None,
 2137    ):
 2138        self.bind_interface = bind_interface if bind_interface is not None else ''
 2139        '''
 2140         Bind interface
 2141        '''
 2142        self.egress_filter = egress_filter if egress_filter is not None else ''
 2143        '''
 2144         A filter applied to the routing logic to pin datasource to nodes.
 2145        '''
 2146        self.healthy = healthy if healthy is not None else False
 2147        '''
 2148         True if the datasource is reachable and the credentials are valid.
 2149        '''
 2150        self.hostname = hostname if hostname is not None else ''
 2151        '''
 2152
 2153        '''
 2154        self.id = id if id is not None else ''
 2155        '''
 2156         Unique identifier of the Resource.
 2157        '''
 2158        self.name = name if name is not None else ''
 2159        '''
 2160         Unique human-readable name of the Resource.
 2161        '''
 2162        self.password = password if password is not None else ''
 2163        '''
 2164
 2165        '''
 2166        self.port = port if port is not None else 0
 2167        '''
 2168
 2169        '''
 2170        self.port_override = port_override if port_override is not None else 0
 2171        '''
 2172
 2173        '''
 2174        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2175        '''
 2176         ID of the secret store containing credentials for this resource, if any.
 2177        '''
 2178        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2179        '''
 2180         Tags is a map of key, value pairs.
 2181        '''
 2182        self.tls_required = tls_required if tls_required is not None else False
 2183        '''
 2184
 2185        '''
 2186        self.username = username if username is not None else ''
 2187        '''
 2188
 2189        '''
 2190
 2191    def __repr__(self):
 2192        return '<sdm.AmazonMQAMQP091 ' + \
 2193            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2194            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2195            'healthy: ' + repr(self.healthy) + ' ' +\
 2196            'hostname: ' + repr(self.hostname) + ' ' +\
 2197            'id: ' + repr(self.id) + ' ' +\
 2198            'name: ' + repr(self.name) + ' ' +\
 2199            'password: ' + repr(self.password) + ' ' +\
 2200            'port: ' + repr(self.port) + ' ' +\
 2201            'port_override: ' + repr(self.port_override) + ' ' +\
 2202            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2203            'tags: ' + repr(self.tags) + ' ' +\
 2204            'tls_required: ' + repr(self.tls_required) + ' ' +\
 2205            'username: ' + repr(self.username) + ' ' +\
 2206            '>'
 2207
 2208    def to_dict(self):
 2209        return {
 2210            'bind_interface': self.bind_interface,
 2211            'egress_filter': self.egress_filter,
 2212            'healthy': self.healthy,
 2213            'hostname': self.hostname,
 2214            'id': self.id,
 2215            'name': self.name,
 2216            'password': self.password,
 2217            'port': self.port,
 2218            'port_override': self.port_override,
 2219            'secret_store_id': self.secret_store_id,
 2220            'tags': self.tags,
 2221            'tls_required': self.tls_required,
 2222            'username': self.username,
 2223        }
 2224
 2225    @classmethod
 2226    def from_dict(cls, d):
 2227        return cls(
 2228            bind_interface=d.get('bind_interface'),
 2229            egress_filter=d.get('egress_filter'),
 2230            healthy=d.get('healthy'),
 2231            hostname=d.get('hostname'),
 2232            id=d.get('id'),
 2233            name=d.get('name'),
 2234            password=d.get('password'),
 2235            port=d.get('port'),
 2236            port_override=d.get('port_override'),
 2237            secret_store_id=d.get('secret_store_id'),
 2238            tags=d.get('tags'),
 2239            tls_required=d.get('tls_required'),
 2240            username=d.get('username'),
 2241        )
 2242
 2243
 2244class Athena:
 2245    '''
 2246
 2247    '''
 2248    __slots__ = [
 2249        'access_key',
 2250        'bind_interface',
 2251        'egress_filter',
 2252        'healthy',
 2253        'id',
 2254        'name',
 2255        'output',
 2256        'port_override',
 2257        'region',
 2258        'role_arn',
 2259        'role_external_id',
 2260        'secret_access_key',
 2261        'secret_store_id',
 2262        'tags',
 2263    ]
 2264
 2265    def __init__(
 2266        self,
 2267        access_key=None,
 2268        bind_interface=None,
 2269        egress_filter=None,
 2270        healthy=None,
 2271        id=None,
 2272        name=None,
 2273        output=None,
 2274        port_override=None,
 2275        region=None,
 2276        role_arn=None,
 2277        role_external_id=None,
 2278        secret_access_key=None,
 2279        secret_store_id=None,
 2280        tags=None,
 2281    ):
 2282        self.access_key = access_key if access_key is not None else ''
 2283        '''
 2284
 2285        '''
 2286        self.bind_interface = bind_interface if bind_interface is not None else ''
 2287        '''
 2288         Bind interface
 2289        '''
 2290        self.egress_filter = egress_filter if egress_filter is not None else ''
 2291        '''
 2292         A filter applied to the routing logic to pin datasource to nodes.
 2293        '''
 2294        self.healthy = healthy if healthy is not None else False
 2295        '''
 2296         True if the datasource is reachable and the credentials are valid.
 2297        '''
 2298        self.id = id if id is not None else ''
 2299        '''
 2300         Unique identifier of the Resource.
 2301        '''
 2302        self.name = name if name is not None else ''
 2303        '''
 2304         Unique human-readable name of the Resource.
 2305        '''
 2306        self.output = output if output is not None else ''
 2307        '''
 2308
 2309        '''
 2310        self.port_override = port_override if port_override is not None else 0
 2311        '''
 2312
 2313        '''
 2314        self.region = region if region is not None else ''
 2315        '''
 2316
 2317        '''
 2318        self.role_arn = role_arn if role_arn is not None else ''
 2319        '''
 2320
 2321        '''
 2322        self.role_external_id = role_external_id if role_external_id is not None else ''
 2323        '''
 2324
 2325        '''
 2326        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2327        '''
 2328
 2329        '''
 2330        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2331        '''
 2332         ID of the secret store containing credentials for this resource, if any.
 2333        '''
 2334        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2335        '''
 2336         Tags is a map of key, value pairs.
 2337        '''
 2338
 2339    def __repr__(self):
 2340        return '<sdm.Athena ' + \
 2341            'access_key: ' + repr(self.access_key) + ' ' +\
 2342            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2343            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2344            'healthy: ' + repr(self.healthy) + ' ' +\
 2345            'id: ' + repr(self.id) + ' ' +\
 2346            'name: ' + repr(self.name) + ' ' +\
 2347            'output: ' + repr(self.output) + ' ' +\
 2348            'port_override: ' + repr(self.port_override) + ' ' +\
 2349            'region: ' + repr(self.region) + ' ' +\
 2350            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2351            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2352            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2353            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2354            'tags: ' + repr(self.tags) + ' ' +\
 2355            '>'
 2356
 2357    def to_dict(self):
 2358        return {
 2359            'access_key': self.access_key,
 2360            'bind_interface': self.bind_interface,
 2361            'egress_filter': self.egress_filter,
 2362            'healthy': self.healthy,
 2363            'id': self.id,
 2364            'name': self.name,
 2365            'output': self.output,
 2366            'port_override': self.port_override,
 2367            'region': self.region,
 2368            'role_arn': self.role_arn,
 2369            'role_external_id': self.role_external_id,
 2370            'secret_access_key': self.secret_access_key,
 2371            'secret_store_id': self.secret_store_id,
 2372            'tags': self.tags,
 2373        }
 2374
 2375    @classmethod
 2376    def from_dict(cls, d):
 2377        return cls(
 2378            access_key=d.get('access_key'),
 2379            bind_interface=d.get('bind_interface'),
 2380            egress_filter=d.get('egress_filter'),
 2381            healthy=d.get('healthy'),
 2382            id=d.get('id'),
 2383            name=d.get('name'),
 2384            output=d.get('output'),
 2385            port_override=d.get('port_override'),
 2386            region=d.get('region'),
 2387            role_arn=d.get('role_arn'),
 2388            role_external_id=d.get('role_external_id'),
 2389            secret_access_key=d.get('secret_access_key'),
 2390            secret_store_id=d.get('secret_store_id'),
 2391            tags=d.get('tags'),
 2392        )
 2393
 2394
 2395class AuroraMysql:
 2396    '''
 2397
 2398    '''
 2399    __slots__ = [
 2400        'bind_interface',
 2401        'database',
 2402        'egress_filter',
 2403        'healthy',
 2404        'hostname',
 2405        'id',
 2406        'name',
 2407        'password',
 2408        'port',
 2409        'port_override',
 2410        'secret_store_id',
 2411        'tags',
 2412        'username',
 2413    ]
 2414
 2415    def __init__(
 2416        self,
 2417        bind_interface=None,
 2418        database=None,
 2419        egress_filter=None,
 2420        healthy=None,
 2421        hostname=None,
 2422        id=None,
 2423        name=None,
 2424        password=None,
 2425        port=None,
 2426        port_override=None,
 2427        secret_store_id=None,
 2428        tags=None,
 2429        username=None,
 2430    ):
 2431        self.bind_interface = bind_interface if bind_interface is not None else ''
 2432        '''
 2433         Bind interface
 2434        '''
 2435        self.database = database if database is not None else ''
 2436        '''
 2437
 2438        '''
 2439        self.egress_filter = egress_filter if egress_filter is not None else ''
 2440        '''
 2441         A filter applied to the routing logic to pin datasource to nodes.
 2442        '''
 2443        self.healthy = healthy if healthy is not None else False
 2444        '''
 2445         True if the datasource is reachable and the credentials are valid.
 2446        '''
 2447        self.hostname = hostname if hostname is not None else ''
 2448        '''
 2449
 2450        '''
 2451        self.id = id if id is not None else ''
 2452        '''
 2453         Unique identifier of the Resource.
 2454        '''
 2455        self.name = name if name is not None else ''
 2456        '''
 2457         Unique human-readable name of the Resource.
 2458        '''
 2459        self.password = password if password is not None else ''
 2460        '''
 2461
 2462        '''
 2463        self.port = port if port is not None else 0
 2464        '''
 2465
 2466        '''
 2467        self.port_override = port_override if port_override is not None else 0
 2468        '''
 2469
 2470        '''
 2471        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2472        '''
 2473         ID of the secret store containing credentials for this resource, if any.
 2474        '''
 2475        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2476        '''
 2477         Tags is a map of key, value pairs.
 2478        '''
 2479        self.username = username if username is not None else ''
 2480        '''
 2481
 2482        '''
 2483
 2484    def __repr__(self):
 2485        return '<sdm.AuroraMysql ' + \
 2486            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2487            'database: ' + repr(self.database) + ' ' +\
 2488            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2489            'healthy: ' + repr(self.healthy) + ' ' +\
 2490            'hostname: ' + repr(self.hostname) + ' ' +\
 2491            'id: ' + repr(self.id) + ' ' +\
 2492            'name: ' + repr(self.name) + ' ' +\
 2493            'password: ' + repr(self.password) + ' ' +\
 2494            'port: ' + repr(self.port) + ' ' +\
 2495            'port_override: ' + repr(self.port_override) + ' ' +\
 2496            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2497            'tags: ' + repr(self.tags) + ' ' +\
 2498            'username: ' + repr(self.username) + ' ' +\
 2499            '>'
 2500
 2501    def to_dict(self):
 2502        return {
 2503            'bind_interface': self.bind_interface,
 2504            'database': self.database,
 2505            'egress_filter': self.egress_filter,
 2506            'healthy': self.healthy,
 2507            'hostname': self.hostname,
 2508            'id': self.id,
 2509            'name': self.name,
 2510            'password': self.password,
 2511            'port': self.port,
 2512            'port_override': self.port_override,
 2513            'secret_store_id': self.secret_store_id,
 2514            'tags': self.tags,
 2515            'username': self.username,
 2516        }
 2517
 2518    @classmethod
 2519    def from_dict(cls, d):
 2520        return cls(
 2521            bind_interface=d.get('bind_interface'),
 2522            database=d.get('database'),
 2523            egress_filter=d.get('egress_filter'),
 2524            healthy=d.get('healthy'),
 2525            hostname=d.get('hostname'),
 2526            id=d.get('id'),
 2527            name=d.get('name'),
 2528            password=d.get('password'),
 2529            port=d.get('port'),
 2530            port_override=d.get('port_override'),
 2531            secret_store_id=d.get('secret_store_id'),
 2532            tags=d.get('tags'),
 2533            username=d.get('username'),
 2534        )
 2535
 2536
 2537class AuroraPostgres:
 2538    '''
 2539
 2540    '''
 2541    __slots__ = [
 2542        'bind_interface',
 2543        'database',
 2544        'egress_filter',
 2545        'healthy',
 2546        'hostname',
 2547        'id',
 2548        'name',
 2549        'override_database',
 2550        'password',
 2551        'port',
 2552        'port_override',
 2553        'secret_store_id',
 2554        'tags',
 2555        'username',
 2556    ]
 2557
 2558    def __init__(
 2559        self,
 2560        bind_interface=None,
 2561        database=None,
 2562        egress_filter=None,
 2563        healthy=None,
 2564        hostname=None,
 2565        id=None,
 2566        name=None,
 2567        override_database=None,
 2568        password=None,
 2569        port=None,
 2570        port_override=None,
 2571        secret_store_id=None,
 2572        tags=None,
 2573        username=None,
 2574    ):
 2575        self.bind_interface = bind_interface if bind_interface is not None else ''
 2576        '''
 2577         Bind interface
 2578        '''
 2579        self.database = database if database is not None else ''
 2580        '''
 2581
 2582        '''
 2583        self.egress_filter = egress_filter if egress_filter is not None else ''
 2584        '''
 2585         A filter applied to the routing logic to pin datasource to nodes.
 2586        '''
 2587        self.healthy = healthy if healthy is not None else False
 2588        '''
 2589         True if the datasource is reachable and the credentials are valid.
 2590        '''
 2591        self.hostname = hostname if hostname is not None else ''
 2592        '''
 2593
 2594        '''
 2595        self.id = id if id is not None else ''
 2596        '''
 2597         Unique identifier of the Resource.
 2598        '''
 2599        self.name = name if name is not None else ''
 2600        '''
 2601         Unique human-readable name of the Resource.
 2602        '''
 2603        self.override_database = override_database if override_database is not None else False
 2604        '''
 2605
 2606        '''
 2607        self.password = password if password is not None else ''
 2608        '''
 2609
 2610        '''
 2611        self.port = port if port is not None else 0
 2612        '''
 2613
 2614        '''
 2615        self.port_override = port_override if port_override is not None else 0
 2616        '''
 2617
 2618        '''
 2619        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2620        '''
 2621         ID of the secret store containing credentials for this resource, if any.
 2622        '''
 2623        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2624        '''
 2625         Tags is a map of key, value pairs.
 2626        '''
 2627        self.username = username if username is not None else ''
 2628        '''
 2629
 2630        '''
 2631
 2632    def __repr__(self):
 2633        return '<sdm.AuroraPostgres ' + \
 2634            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2635            'database: ' + repr(self.database) + ' ' +\
 2636            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2637            'healthy: ' + repr(self.healthy) + ' ' +\
 2638            'hostname: ' + repr(self.hostname) + ' ' +\
 2639            'id: ' + repr(self.id) + ' ' +\
 2640            'name: ' + repr(self.name) + ' ' +\
 2641            'override_database: ' + repr(self.override_database) + ' ' +\
 2642            'password: ' + repr(self.password) + ' ' +\
 2643            'port: ' + repr(self.port) + ' ' +\
 2644            'port_override: ' + repr(self.port_override) + ' ' +\
 2645            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2646            'tags: ' + repr(self.tags) + ' ' +\
 2647            'username: ' + repr(self.username) + ' ' +\
 2648            '>'
 2649
 2650    def to_dict(self):
 2651        return {
 2652            'bind_interface': self.bind_interface,
 2653            'database': self.database,
 2654            'egress_filter': self.egress_filter,
 2655            'healthy': self.healthy,
 2656            'hostname': self.hostname,
 2657            'id': self.id,
 2658            'name': self.name,
 2659            'override_database': self.override_database,
 2660            'password': self.password,
 2661            'port': self.port,
 2662            'port_override': self.port_override,
 2663            'secret_store_id': self.secret_store_id,
 2664            'tags': self.tags,
 2665            'username': self.username,
 2666        }
 2667
 2668    @classmethod
 2669    def from_dict(cls, d):
 2670        return cls(
 2671            bind_interface=d.get('bind_interface'),
 2672            database=d.get('database'),
 2673            egress_filter=d.get('egress_filter'),
 2674            healthy=d.get('healthy'),
 2675            hostname=d.get('hostname'),
 2676            id=d.get('id'),
 2677            name=d.get('name'),
 2678            override_database=d.get('override_database'),
 2679            password=d.get('password'),
 2680            port=d.get('port'),
 2681            port_override=d.get('port_override'),
 2682            secret_store_id=d.get('secret_store_id'),
 2683            tags=d.get('tags'),
 2684            username=d.get('username'),
 2685        )
 2686
 2687
 2688class Azure:
 2689    '''
 2690
 2691    '''
 2692    __slots__ = [
 2693        'app_id',
 2694        'bind_interface',
 2695        'egress_filter',
 2696        'healthy',
 2697        'id',
 2698        'name',
 2699        'password',
 2700        'secret_store_id',
 2701        'tags',
 2702        'tenant_id',
 2703    ]
 2704
 2705    def __init__(
 2706        self,
 2707        app_id=None,
 2708        bind_interface=None,
 2709        egress_filter=None,
 2710        healthy=None,
 2711        id=None,
 2712        name=None,
 2713        password=None,
 2714        secret_store_id=None,
 2715        tags=None,
 2716        tenant_id=None,
 2717    ):
 2718        self.app_id = app_id if app_id is not None else ''
 2719        '''
 2720
 2721        '''
 2722        self.bind_interface = bind_interface if bind_interface is not None else ''
 2723        '''
 2724         Bind interface
 2725        '''
 2726        self.egress_filter = egress_filter if egress_filter is not None else ''
 2727        '''
 2728         A filter applied to the routing logic to pin datasource to nodes.
 2729        '''
 2730        self.healthy = healthy if healthy is not None else False
 2731        '''
 2732         True if the datasource is reachable and the credentials are valid.
 2733        '''
 2734        self.id = id if id is not None else ''
 2735        '''
 2736         Unique identifier of the Resource.
 2737        '''
 2738        self.name = name if name is not None else ''
 2739        '''
 2740         Unique human-readable name of the Resource.
 2741        '''
 2742        self.password = password if password is not None else ''
 2743        '''
 2744
 2745        '''
 2746        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2747        '''
 2748         ID of the secret store containing credentials for this resource, if any.
 2749        '''
 2750        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2751        '''
 2752         Tags is a map of key, value pairs.
 2753        '''
 2754        self.tenant_id = tenant_id if tenant_id is not None else ''
 2755        '''
 2756
 2757        '''
 2758
 2759    def __repr__(self):
 2760        return '<sdm.Azure ' + \
 2761            'app_id: ' + repr(self.app_id) + ' ' +\
 2762            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2763            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2764            'healthy: ' + repr(self.healthy) + ' ' +\
 2765            'id: ' + repr(self.id) + ' ' +\
 2766            'name: ' + repr(self.name) + ' ' +\
 2767            'password: ' + repr(self.password) + ' ' +\
 2768            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2769            'tags: ' + repr(self.tags) + ' ' +\
 2770            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2771            '>'
 2772
 2773    def to_dict(self):
 2774        return {
 2775            'app_id': self.app_id,
 2776            'bind_interface': self.bind_interface,
 2777            'egress_filter': self.egress_filter,
 2778            'healthy': self.healthy,
 2779            'id': self.id,
 2780            'name': self.name,
 2781            'password': self.password,
 2782            'secret_store_id': self.secret_store_id,
 2783            'tags': self.tags,
 2784            'tenant_id': self.tenant_id,
 2785        }
 2786
 2787    @classmethod
 2788    def from_dict(cls, d):
 2789        return cls(
 2790            app_id=d.get('app_id'),
 2791            bind_interface=d.get('bind_interface'),
 2792            egress_filter=d.get('egress_filter'),
 2793            healthy=d.get('healthy'),
 2794            id=d.get('id'),
 2795            name=d.get('name'),
 2796            password=d.get('password'),
 2797            secret_store_id=d.get('secret_store_id'),
 2798            tags=d.get('tags'),
 2799            tenant_id=d.get('tenant_id'),
 2800        )
 2801
 2802
 2803class AzureCertificate:
 2804    '''
 2805
 2806    '''
 2807    __slots__ = [
 2808        'app_id',
 2809        'bind_interface',
 2810        'client_certificate',
 2811        'egress_filter',
 2812        'healthy',
 2813        'id',
 2814        'name',
 2815        'secret_store_id',
 2816        'tags',
 2817        'tenant_id',
 2818    ]
 2819
 2820    def __init__(
 2821        self,
 2822        app_id=None,
 2823        bind_interface=None,
 2824        client_certificate=None,
 2825        egress_filter=None,
 2826        healthy=None,
 2827        id=None,
 2828        name=None,
 2829        secret_store_id=None,
 2830        tags=None,
 2831        tenant_id=None,
 2832    ):
 2833        self.app_id = app_id if app_id is not None else ''
 2834        '''
 2835
 2836        '''
 2837        self.bind_interface = bind_interface if bind_interface is not None else ''
 2838        '''
 2839         Bind interface
 2840        '''
 2841        self.client_certificate = client_certificate if client_certificate is not None else ''
 2842        '''
 2843
 2844        '''
 2845        self.egress_filter = egress_filter if egress_filter is not None else ''
 2846        '''
 2847         A filter applied to the routing logic to pin datasource to nodes.
 2848        '''
 2849        self.healthy = healthy if healthy is not None else False
 2850        '''
 2851         True if the datasource is reachable and the credentials are valid.
 2852        '''
 2853        self.id = id if id is not None else ''
 2854        '''
 2855         Unique identifier of the Resource.
 2856        '''
 2857        self.name = name if name is not None else ''
 2858        '''
 2859         Unique human-readable name of the Resource.
 2860        '''
 2861        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2862        '''
 2863         ID of the secret store containing credentials for this resource, if any.
 2864        '''
 2865        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2866        '''
 2867         Tags is a map of key, value pairs.
 2868        '''
 2869        self.tenant_id = tenant_id if tenant_id is not None else ''
 2870        '''
 2871
 2872        '''
 2873
 2874    def __repr__(self):
 2875        return '<sdm.AzureCertificate ' + \
 2876            'app_id: ' + repr(self.app_id) + ' ' +\
 2877            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2878            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 2879            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2880            'healthy: ' + repr(self.healthy) + ' ' +\
 2881            'id: ' + repr(self.id) + ' ' +\
 2882            'name: ' + repr(self.name) + ' ' +\
 2883            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2884            'tags: ' + repr(self.tags) + ' ' +\
 2885            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2886            '>'
 2887
 2888    def to_dict(self):
 2889        return {
 2890            'app_id': self.app_id,
 2891            'bind_interface': self.bind_interface,
 2892            'client_certificate': self.client_certificate,
 2893            'egress_filter': self.egress_filter,
 2894            'healthy': self.healthy,
 2895            'id': self.id,
 2896            'name': self.name,
 2897            'secret_store_id': self.secret_store_id,
 2898            'tags': self.tags,
 2899            'tenant_id': self.tenant_id,
 2900        }
 2901
 2902    @classmethod
 2903    def from_dict(cls, d):
 2904        return cls(
 2905            app_id=d.get('app_id'),
 2906            bind_interface=d.get('bind_interface'),
 2907            client_certificate=d.get('client_certificate'),
 2908            egress_filter=d.get('egress_filter'),
 2909            healthy=d.get('healthy'),
 2910            id=d.get('id'),
 2911            name=d.get('name'),
 2912            secret_store_id=d.get('secret_store_id'),
 2913            tags=d.get('tags'),
 2914            tenant_id=d.get('tenant_id'),
 2915        )
 2916
 2917
 2918class AzurePostgres:
 2919    '''
 2920
 2921    '''
 2922    __slots__ = [
 2923        'bind_interface',
 2924        'database',
 2925        'egress_filter',
 2926        'healthy',
 2927        'hostname',
 2928        'id',
 2929        'name',
 2930        'override_database',
 2931        'password',
 2932        'port',
 2933        'port_override',
 2934        'secret_store_id',
 2935        'tags',
 2936        'username',
 2937    ]
 2938
 2939    def __init__(
 2940        self,
 2941        bind_interface=None,
 2942        database=None,
 2943        egress_filter=None,
 2944        healthy=None,
 2945        hostname=None,
 2946        id=None,
 2947        name=None,
 2948        override_database=None,
 2949        password=None,
 2950        port=None,
 2951        port_override=None,
 2952        secret_store_id=None,
 2953        tags=None,
 2954        username=None,
 2955    ):
 2956        self.bind_interface = bind_interface if bind_interface is not None else ''
 2957        '''
 2958         Bind interface
 2959        '''
 2960        self.database = database if database is not None else ''
 2961        '''
 2962
 2963        '''
 2964        self.egress_filter = egress_filter if egress_filter is not None else ''
 2965        '''
 2966         A filter applied to the routing logic to pin datasource to nodes.
 2967        '''
 2968        self.healthy = healthy if healthy is not None else False
 2969        '''
 2970         True if the datasource is reachable and the credentials are valid.
 2971        '''
 2972        self.hostname = hostname if hostname is not None else ''
 2973        '''
 2974
 2975        '''
 2976        self.id = id if id is not None else ''
 2977        '''
 2978         Unique identifier of the Resource.
 2979        '''
 2980        self.name = name if name is not None else ''
 2981        '''
 2982         Unique human-readable name of the Resource.
 2983        '''
 2984        self.override_database = override_database if override_database is not None else False
 2985        '''
 2986
 2987        '''
 2988        self.password = password if password is not None else ''
 2989        '''
 2990
 2991        '''
 2992        self.port = port if port is not None else 0
 2993        '''
 2994
 2995        '''
 2996        self.port_override = port_override if port_override is not None else 0
 2997        '''
 2998
 2999        '''
 3000        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3001        '''
 3002         ID of the secret store containing credentials for this resource, if any.
 3003        '''
 3004        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3005        '''
 3006         Tags is a map of key, value pairs.
 3007        '''
 3008        self.username = username if username is not None else ''
 3009        '''
 3010
 3011        '''
 3012
 3013    def __repr__(self):
 3014        return '<sdm.AzurePostgres ' + \
 3015            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3016            'database: ' + repr(self.database) + ' ' +\
 3017            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3018            'healthy: ' + repr(self.healthy) + ' ' +\
 3019            'hostname: ' + repr(self.hostname) + ' ' +\
 3020            'id: ' + repr(self.id) + ' ' +\
 3021            'name: ' + repr(self.name) + ' ' +\
 3022            'override_database: ' + repr(self.override_database) + ' ' +\
 3023            'password: ' + repr(self.password) + ' ' +\
 3024            'port: ' + repr(self.port) + ' ' +\
 3025            'port_override: ' + repr(self.port_override) + ' ' +\
 3026            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3027            'tags: ' + repr(self.tags) + ' ' +\
 3028            'username: ' + repr(self.username) + ' ' +\
 3029            '>'
 3030
 3031    def to_dict(self):
 3032        return {
 3033            'bind_interface': self.bind_interface,
 3034            'database': self.database,
 3035            'egress_filter': self.egress_filter,
 3036            'healthy': self.healthy,
 3037            'hostname': self.hostname,
 3038            'id': self.id,
 3039            'name': self.name,
 3040            'override_database': self.override_database,
 3041            'password': self.password,
 3042            'port': self.port,
 3043            'port_override': self.port_override,
 3044            'secret_store_id': self.secret_store_id,
 3045            'tags': self.tags,
 3046            'username': self.username,
 3047        }
 3048
 3049    @classmethod
 3050    def from_dict(cls, d):
 3051        return cls(
 3052            bind_interface=d.get('bind_interface'),
 3053            database=d.get('database'),
 3054            egress_filter=d.get('egress_filter'),
 3055            healthy=d.get('healthy'),
 3056            hostname=d.get('hostname'),
 3057            id=d.get('id'),
 3058            name=d.get('name'),
 3059            override_database=d.get('override_database'),
 3060            password=d.get('password'),
 3061            port=d.get('port'),
 3062            port_override=d.get('port_override'),
 3063            secret_store_id=d.get('secret_store_id'),
 3064            tags=d.get('tags'),
 3065            username=d.get('username'),
 3066        )
 3067
 3068
 3069class AzureStore:
 3070    '''
 3071
 3072    '''
 3073    __slots__ = [
 3074        'id',
 3075        'name',
 3076        'tags',
 3077        'vault_uri',
 3078    ]
 3079
 3080    def __init__(
 3081        self,
 3082        id=None,
 3083        name=None,
 3084        tags=None,
 3085        vault_uri=None,
 3086    ):
 3087        self.id = id if id is not None else ''
 3088        '''
 3089         Unique identifier of the SecretStore.
 3090        '''
 3091        self.name = name if name is not None else ''
 3092        '''
 3093         Unique human-readable name of the SecretStore.
 3094        '''
 3095        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3096        '''
 3097         Tags is a map of key, value pairs.
 3098        '''
 3099        self.vault_uri = vault_uri if vault_uri is not None else ''
 3100        '''
 3101
 3102        '''
 3103
 3104    def __repr__(self):
 3105        return '<sdm.AzureStore ' + \
 3106            'id: ' + repr(self.id) + ' ' +\
 3107            'name: ' + repr(self.name) + ' ' +\
 3108            'tags: ' + repr(self.tags) + ' ' +\
 3109            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
 3110            '>'
 3111
 3112    def to_dict(self):
 3113        return {
 3114            'id': self.id,
 3115            'name': self.name,
 3116            'tags': self.tags,
 3117            'vault_uri': self.vault_uri,
 3118        }
 3119
 3120    @classmethod
 3121    def from_dict(cls, d):
 3122        return cls(
 3123            id=d.get('id'),
 3124            name=d.get('name'),
 3125            tags=d.get('tags'),
 3126            vault_uri=d.get('vault_uri'),
 3127        )
 3128
 3129
 3130class BigQuery:
 3131    '''
 3132
 3133    '''
 3134    __slots__ = [
 3135        'bind_interface',
 3136        'egress_filter',
 3137        'endpoint',
 3138        'healthy',
 3139        'id',
 3140        'name',
 3141        'port_override',
 3142        'private_key',
 3143        'project',
 3144        'secret_store_id',
 3145        'tags',
 3146        'username',
 3147    ]
 3148
 3149    def __init__(
 3150        self,
 3151        bind_interface=None,
 3152        egress_filter=None,
 3153        endpoint=None,
 3154        healthy=None,
 3155        id=None,
 3156        name=None,
 3157        port_override=None,
 3158        private_key=None,
 3159        project=None,
 3160        secret_store_id=None,
 3161        tags=None,
 3162        username=None,
 3163    ):
 3164        self.bind_interface = bind_interface if bind_interface is not None else ''
 3165        '''
 3166         Bind interface
 3167        '''
 3168        self.egress_filter = egress_filter if egress_filter is not None else ''
 3169        '''
 3170         A filter applied to the routing logic to pin datasource to nodes.
 3171        '''
 3172        self.endpoint = endpoint if endpoint is not None else ''
 3173        '''
 3174
 3175        '''
 3176        self.healthy = healthy if healthy is not None else False
 3177        '''
 3178         True if the datasource is reachable and the credentials are valid.
 3179        '''
 3180        self.id = id if id is not None else ''
 3181        '''
 3182         Unique identifier of the Resource.
 3183        '''
 3184        self.name = name if name is not None else ''
 3185        '''
 3186         Unique human-readable name of the Resource.
 3187        '''
 3188        self.port_override = port_override if port_override is not None else 0
 3189        '''
 3190
 3191        '''
 3192        self.private_key = private_key if private_key is not None else ''
 3193        '''
 3194
 3195        '''
 3196        self.project = project if project is not None else ''
 3197        '''
 3198
 3199        '''
 3200        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3201        '''
 3202         ID of the secret store containing credentials for this resource, if any.
 3203        '''
 3204        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3205        '''
 3206         Tags is a map of key, value pairs.
 3207        '''
 3208        self.username = username if username is not None else ''
 3209        '''
 3210
 3211        '''
 3212
 3213    def __repr__(self):
 3214        return '<sdm.BigQuery ' + \
 3215            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3216            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3217            'endpoint: ' + repr(self.endpoint) + ' ' +\
 3218            'healthy: ' + repr(self.healthy) + ' ' +\
 3219            'id: ' + repr(self.id) + ' ' +\
 3220            'name: ' + repr(self.name) + ' ' +\
 3221            'port_override: ' + repr(self.port_override) + ' ' +\
 3222            'private_key: ' + repr(self.private_key) + ' ' +\
 3223            'project: ' + repr(self.project) + ' ' +\
 3224            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3225            'tags: ' + repr(self.tags) + ' ' +\
 3226            'username: ' + repr(self.username) + ' ' +\
 3227            '>'
 3228
 3229    def to_dict(self):
 3230        return {
 3231            'bind_interface': self.bind_interface,
 3232            'egress_filter': self.egress_filter,
 3233            'endpoint': self.endpoint,
 3234            'healthy': self.healthy,
 3235            'id': self.id,
 3236            'name': self.name,
 3237            'port_override': self.port_override,
 3238            'private_key': self.private_key,
 3239            'project': self.project,
 3240            'secret_store_id': self.secret_store_id,
 3241            'tags': self.tags,
 3242            'username': self.username,
 3243        }
 3244
 3245    @classmethod
 3246    def from_dict(cls, d):
 3247        return cls(
 3248            bind_interface=d.get('bind_interface'),
 3249            egress_filter=d.get('egress_filter'),
 3250            endpoint=d.get('endpoint'),
 3251            healthy=d.get('healthy'),
 3252            id=d.get('id'),
 3253            name=d.get('name'),
 3254            port_override=d.get('port_override'),
 3255            private_key=d.get('private_key'),
 3256            project=d.get('project'),
 3257            secret_store_id=d.get('secret_store_id'),
 3258            tags=d.get('tags'),
 3259            username=d.get('username'),
 3260        )
 3261
 3262
 3263class Cassandra:
 3264    '''
 3265
 3266    '''
 3267    __slots__ = [
 3268        'bind_interface',
 3269        'egress_filter',
 3270        'healthy',
 3271        'hostname',
 3272        'id',
 3273        'name',
 3274        'password',
 3275        'port',
 3276        'port_override',
 3277        'secret_store_id',
 3278        'tags',
 3279        'tls_required',
 3280        'username',
 3281    ]
 3282
 3283    def __init__(
 3284        self,
 3285        bind_interface=None,
 3286        egress_filter=None,
 3287        healthy=None,
 3288        hostname=None,
 3289        id=None,
 3290        name=None,
 3291        password=None,
 3292        port=None,
 3293        port_override=None,
 3294        secret_store_id=None,
 3295        tags=None,
 3296        tls_required=None,
 3297        username=None,
 3298    ):
 3299        self.bind_interface = bind_interface if bind_interface is not None else ''
 3300        '''
 3301         Bind interface
 3302        '''
 3303        self.egress_filter = egress_filter if egress_filter is not None else ''
 3304        '''
 3305         A filter applied to the routing logic to pin datasource to nodes.
 3306        '''
 3307        self.healthy = healthy if healthy is not None else False
 3308        '''
 3309         True if the datasource is reachable and the credentials are valid.
 3310        '''
 3311        self.hostname = hostname if hostname is not None else ''
 3312        '''
 3313
 3314        '''
 3315        self.id = id if id is not None else ''
 3316        '''
 3317         Unique identifier of the Resource.
 3318        '''
 3319        self.name = name if name is not None else ''
 3320        '''
 3321         Unique human-readable name of the Resource.
 3322        '''
 3323        self.password = password if password is not None else ''
 3324        '''
 3325
 3326        '''
 3327        self.port = port if port is not None else 0
 3328        '''
 3329
 3330        '''
 3331        self.port_override = port_override if port_override is not None else 0
 3332        '''
 3333
 3334        '''
 3335        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3336        '''
 3337         ID of the secret store containing credentials for this resource, if any.
 3338        '''
 3339        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3340        '''
 3341         Tags is a map of key, value pairs.
 3342        '''
 3343        self.tls_required = tls_required if tls_required is not None else False
 3344        '''
 3345
 3346        '''
 3347        self.username = username if username is not None else ''
 3348        '''
 3349
 3350        '''
 3351
 3352    def __repr__(self):
 3353        return '<sdm.Cassandra ' + \
 3354            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3355            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3356            'healthy: ' + repr(self.healthy) + ' ' +\
 3357            'hostname: ' + repr(self.hostname) + ' ' +\
 3358            'id: ' + repr(self.id) + ' ' +\
 3359            'name: ' + repr(self.name) + ' ' +\
 3360            'password: ' + repr(self.password) + ' ' +\
 3361            'port: ' + repr(self.port) + ' ' +\
 3362            'port_override: ' + repr(self.port_override) + ' ' +\
 3363            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3364            'tags: ' + repr(self.tags) + ' ' +\
 3365            'tls_required: ' + repr(self.tls_required) + ' ' +\
 3366            'username: ' + repr(self.username) + ' ' +\
 3367            '>'
 3368
 3369    def to_dict(self):
 3370        return {
 3371            'bind_interface': self.bind_interface,
 3372            'egress_filter': self.egress_filter,
 3373            'healthy': self.healthy,
 3374            'hostname': self.hostname,
 3375            'id': self.id,
 3376            'name': self.name,
 3377            'password': self.password,
 3378            'port': self.port,
 3379            'port_override': self.port_override,
 3380            'secret_store_id': self.secret_store_id,
 3381            'tags': self.tags,
 3382            'tls_required': self.tls_required,
 3383            'username': self.username,
 3384        }
 3385
 3386    @classmethod
 3387    def from_dict(cls, d):
 3388        return cls(
 3389            bind_interface=d.get('bind_interface'),
 3390            egress_filter=d.get('egress_filter'),
 3391            healthy=d.get('healthy'),
 3392            hostname=d.get('hostname'),
 3393            id=d.get('id'),
 3394            name=d.get('name'),
 3395            password=d.get('password'),
 3396            port=d.get('port'),
 3397            port_override=d.get('port_override'),
 3398            secret_store_id=d.get('secret_store_id'),
 3399            tags=d.get('tags'),
 3400            tls_required=d.get('tls_required'),
 3401            username=d.get('username'),
 3402        )
 3403
 3404
 3405class Citus:
 3406    '''
 3407
 3408    '''
 3409    __slots__ = [
 3410        'bind_interface',
 3411        'database',
 3412        'egress_filter',
 3413        'healthy',
 3414        'hostname',
 3415        'id',
 3416        'name',
 3417        'override_database',
 3418        'password',
 3419        'port',
 3420        'port_override',
 3421        'secret_store_id',
 3422        'tags',
 3423        'username',
 3424    ]
 3425
 3426    def __init__(
 3427        self,
 3428        bind_interface=None,
 3429        database=None,
 3430        egress_filter=None,
 3431        healthy=None,
 3432        hostname=None,
 3433        id=None,
 3434        name=None,
 3435        override_database=None,
 3436        password=None,
 3437        port=None,
 3438        port_override=None,
 3439        secret_store_id=None,
 3440        tags=None,
 3441        username=None,
 3442    ):
 3443        self.bind_interface = bind_interface if bind_interface is not None else ''
 3444        '''
 3445         Bind interface
 3446        '''
 3447        self.database = database if database is not None else ''
 3448        '''
 3449
 3450        '''
 3451        self.egress_filter = egress_filter if egress_filter is not None else ''
 3452        '''
 3453         A filter applied to the routing logic to pin datasource to nodes.
 3454        '''
 3455        self.healthy = healthy if healthy is not None else False
 3456        '''
 3457         True if the datasource is reachable and the credentials are valid.
 3458        '''
 3459        self.hostname = hostname if hostname is not None else ''
 3460        '''
 3461
 3462        '''
 3463        self.id = id if id is not None else ''
 3464        '''
 3465         Unique identifier of the Resource.
 3466        '''
 3467        self.name = name if name is not None else ''
 3468        '''
 3469         Unique human-readable name of the Resource.
 3470        '''
 3471        self.override_database = override_database if override_database is not None else False
 3472        '''
 3473
 3474        '''
 3475        self.password = password if password is not None else ''
 3476        '''
 3477
 3478        '''
 3479        self.port = port if port is not None else 0
 3480        '''
 3481
 3482        '''
 3483        self.port_override = port_override if port_override is not None else 0
 3484        '''
 3485
 3486        '''
 3487        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3488        '''
 3489         ID of the secret store containing credentials for this resource, if any.
 3490        '''
 3491        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3492        '''
 3493         Tags is a map of key, value pairs.
 3494        '''
 3495        self.username = username if username is not None else ''
 3496        '''
 3497
 3498        '''
 3499
 3500    def __repr__(self):
 3501        return '<sdm.Citus ' + \
 3502            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3503            'database: ' + repr(self.database) + ' ' +\
 3504            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3505            'healthy: ' + repr(self.healthy) + ' ' +\
 3506            'hostname: ' + repr(self.hostname) + ' ' +\
 3507            'id: ' + repr(self.id) + ' ' +\
 3508            'name: ' + repr(self.name) + ' ' +\
 3509            'override_database: ' + repr(self.override_database) + ' ' +\
 3510            'password: ' + repr(self.password) + ' ' +\
 3511            'port: ' + repr(self.port) + ' ' +\
 3512            'port_override: ' + repr(self.port_override) + ' ' +\
 3513            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3514            'tags: ' + repr(self.tags) + ' ' +\
 3515            'username: ' + repr(self.username) + ' ' +\
 3516            '>'
 3517
 3518    def to_dict(self):
 3519        return {
 3520            'bind_interface': self.bind_interface,
 3521            'database': self.database,
 3522            'egress_filter': self.egress_filter,
 3523            'healthy': self.healthy,
 3524            'hostname': self.hostname,
 3525            'id': self.id,
 3526            'name': self.name,
 3527            'override_database': self.override_database,
 3528            'password': self.password,
 3529            'port': self.port,
 3530            'port_override': self.port_override,
 3531            'secret_store_id': self.secret_store_id,
 3532            'tags': self.tags,
 3533            'username': self.username,
 3534        }
 3535
 3536    @classmethod
 3537    def from_dict(cls, d):
 3538        return cls(
 3539            bind_interface=d.get('bind_interface'),
 3540            database=d.get('database'),
 3541            egress_filter=d.get('egress_filter'),
 3542            healthy=d.get('healthy'),
 3543            hostname=d.get('hostname'),
 3544            id=d.get('id'),
 3545            name=d.get('name'),
 3546            override_database=d.get('override_database'),
 3547            password=d.get('password'),
 3548            port=d.get('port'),
 3549            port_override=d.get('port_override'),
 3550            secret_store_id=d.get('secret_store_id'),
 3551            tags=d.get('tags'),
 3552            username=d.get('username'),
 3553        )
 3554
 3555
 3556class Clustrix:
 3557    '''
 3558
 3559    '''
 3560    __slots__ = [
 3561        'bind_interface',
 3562        'database',
 3563        'egress_filter',
 3564        'healthy',
 3565        'hostname',
 3566        'id',
 3567        'name',
 3568        'password',
 3569        'port',
 3570        'port_override',
 3571        'secret_store_id',
 3572        'tags',
 3573        'username',
 3574    ]
 3575
 3576    def __init__(
 3577        self,
 3578        bind_interface=None,
 3579        database=None,
 3580        egress_filter=None,
 3581        healthy=None,
 3582        hostname=None,
 3583        id=None,
 3584        name=None,
 3585        password=None,
 3586        port=None,
 3587        port_override=None,
 3588        secret_store_id=None,
 3589        tags=None,
 3590        username=None,
 3591    ):
 3592        self.bind_interface = bind_interface if bind_interface is not None else ''
 3593        '''
 3594         Bind interface
 3595        '''
 3596        self.database = database if database is not None else ''
 3597        '''
 3598
 3599        '''
 3600        self.egress_filter = egress_filter if egress_filter is not None else ''
 3601        '''
 3602         A filter applied to the routing logic to pin datasource to nodes.
 3603        '''
 3604        self.healthy = healthy if healthy is not None else False
 3605        '''
 3606         True if the datasource is reachable and the credentials are valid.
 3607        '''
 3608        self.hostname = hostname if hostname is not None else ''
 3609        '''
 3610
 3611        '''
 3612        self.id = id if id is not None else ''
 3613        '''
 3614         Unique identifier of the Resource.
 3615        '''
 3616        self.name = name if name is not None else ''
 3617        '''
 3618         Unique human-readable name of the Resource.
 3619        '''
 3620        self.password = password if password is not None else ''
 3621        '''
 3622
 3623        '''
 3624        self.port = port if port is not None else 0
 3625        '''
 3626
 3627        '''
 3628        self.port_override = port_override if port_override is not None else 0
 3629        '''
 3630
 3631        '''
 3632        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3633        '''
 3634         ID of the secret store containing credentials for this resource, if any.
 3635        '''
 3636        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3637        '''
 3638         Tags is a map of key, value pairs.
 3639        '''
 3640        self.username = username if username is not None else ''
 3641        '''
 3642
 3643        '''
 3644
 3645    def __repr__(self):
 3646        return '<sdm.Clustrix ' + \
 3647            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3648            'database: ' + repr(self.database) + ' ' +\
 3649            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3650            'healthy: ' + repr(self.healthy) + ' ' +\
 3651            'hostname: ' + repr(self.hostname) + ' ' +\
 3652            'id: ' + repr(self.id) + ' ' +\
 3653            'name: ' + repr(self.name) + ' ' +\
 3654            'password: ' + repr(self.password) + ' ' +\
 3655            'port: ' + repr(self.port) + ' ' +\
 3656            'port_override: ' + repr(self.port_override) + ' ' +\
 3657            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3658            'tags: ' + repr(self.tags) + ' ' +\
 3659            'username: ' + repr(self.username) + ' ' +\
 3660            '>'
 3661
 3662    def to_dict(self):
 3663        return {
 3664            'bind_interface': self.bind_interface,
 3665            'database': self.database,
 3666            'egress_filter': self.egress_filter,
 3667            'healthy': self.healthy,
 3668            'hostname': self.hostname,
 3669            'id': self.id,
 3670            'name': self.name,
 3671            'password': self.password,
 3672            'port': self.port,
 3673            'port_override': self.port_override,
 3674            'secret_store_id': self.secret_store_id,
 3675            'tags': self.tags,
 3676            'username': self.username,
 3677        }
 3678
 3679    @classmethod
 3680    def from_dict(cls, d):
 3681        return cls(
 3682            bind_interface=d.get('bind_interface'),
 3683            database=d.get('database'),
 3684            egress_filter=d.get('egress_filter'),
 3685            healthy=d.get('healthy'),
 3686            hostname=d.get('hostname'),
 3687            id=d.get('id'),
 3688            name=d.get('name'),
 3689            password=d.get('password'),
 3690            port=d.get('port'),
 3691            port_override=d.get('port_override'),
 3692            secret_store_id=d.get('secret_store_id'),
 3693            tags=d.get('tags'),
 3694            username=d.get('username'),
 3695        )
 3696
 3697
 3698class Cockroach:
 3699    '''
 3700
 3701    '''
 3702    __slots__ = [
 3703        'bind_interface',
 3704        'database',
 3705        'egress_filter',
 3706        'healthy',
 3707        'hostname',
 3708        'id',
 3709        'name',
 3710        'override_database',
 3711        'password',
 3712        'port',
 3713        'port_override',
 3714        'secret_store_id',
 3715        'tags',
 3716        'username',
 3717    ]
 3718
 3719    def __init__(
 3720        self,
 3721        bind_interface=None,
 3722        database=None,
 3723        egress_filter=None,
 3724        healthy=None,
 3725        hostname=None,
 3726        id=None,
 3727        name=None,
 3728        override_database=None,
 3729        password=None,
 3730        port=None,
 3731        port_override=None,
 3732        secret_store_id=None,
 3733        tags=None,
 3734        username=None,
 3735    ):
 3736        self.bind_interface = bind_interface if bind_interface is not None else ''
 3737        '''
 3738         Bind interface
 3739        '''
 3740        self.database = database if database is not None else ''
 3741        '''
 3742
 3743        '''
 3744        self.egress_filter = egress_filter if egress_filter is not None else ''
 3745        '''
 3746         A filter applied to the routing logic to pin datasource to nodes.
 3747        '''
 3748        self.healthy = healthy if healthy is not None else False
 3749        '''
 3750         True if the datasource is reachable and the credentials are valid.
 3751        '''
 3752        self.hostname = hostname if hostname is not None else ''
 3753        '''
 3754
 3755        '''
 3756        self.id = id if id is not None else ''
 3757        '''
 3758         Unique identifier of the Resource.
 3759        '''
 3760        self.name = name if name is not None else ''
 3761        '''
 3762         Unique human-readable name of the Resource.
 3763        '''
 3764        self.override_database = override_database if override_database is not None else False
 3765        '''
 3766
 3767        '''
 3768        self.password = password if password is not None else ''
 3769        '''
 3770
 3771        '''
 3772        self.port = port if port is not None else 0
 3773        '''
 3774
 3775        '''
 3776        self.port_override = port_override if port_override is not None else 0
 3777        '''
 3778
 3779        '''
 3780        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3781        '''
 3782         ID of the secret store containing credentials for this resource, if any.
 3783        '''
 3784        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3785        '''
 3786         Tags is a map of key, value pairs.
 3787        '''
 3788        self.username = username if username is not None else ''
 3789        '''
 3790
 3791        '''
 3792
 3793    def __repr__(self):
 3794        return '<sdm.Cockroach ' + \
 3795            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3796            'database: ' + repr(self.database) + ' ' +\
 3797            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3798            'healthy: ' + repr(self.healthy) + ' ' +\
 3799            'hostname: ' + repr(self.hostname) + ' ' +\
 3800            'id: ' + repr(self.id) + ' ' +\
 3801            'name: ' + repr(self.name) + ' ' +\
 3802            'override_database: ' + repr(self.override_database) + ' ' +\
 3803            'password: ' + repr(self.password) + ' ' +\
 3804            'port: ' + repr(self.port) + ' ' +\
 3805            'port_override: ' + repr(self.port_override) + ' ' +\
 3806            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3807            'tags: ' + repr(self.tags) + ' ' +\
 3808            'username: ' + repr(self.username) + ' ' +\
 3809            '>'
 3810
 3811    def to_dict(self):
 3812        return {
 3813            'bind_interface': self.bind_interface,
 3814            'database': self.database,
 3815            'egress_filter': self.egress_filter,
 3816            'healthy': self.healthy,
 3817            'hostname': self.hostname,
 3818            'id': self.id,
 3819            'name': self.name,
 3820            'override_database': self.override_database,
 3821            'password': self.password,
 3822            'port': self.port,
 3823            'port_override': self.port_override,
 3824            'secret_store_id': self.secret_store_id,
 3825            'tags': self.tags,
 3826            'username': self.username,
 3827        }
 3828
 3829    @classmethod
 3830    def from_dict(cls, d):
 3831        return cls(
 3832            bind_interface=d.get('bind_interface'),
 3833            database=d.get('database'),
 3834            egress_filter=d.get('egress_filter'),
 3835            healthy=d.get('healthy'),
 3836            hostname=d.get('hostname'),
 3837            id=d.get('id'),
 3838            name=d.get('name'),
 3839            override_database=d.get('override_database'),
 3840            password=d.get('password'),
 3841            port=d.get('port'),
 3842            port_override=d.get('port_override'),
 3843            secret_store_id=d.get('secret_store_id'),
 3844            tags=d.get('tags'),
 3845            username=d.get('username'),
 3846        )
 3847
 3848
 3849class ControlPanelGetSSHCAPublicKeyResponse:
 3850    '''
 3851     ControlPanelGetSSHCAPublicKeyResponse represents a request for an
 3852     organization's SSH Certificate Authority public key.
 3853    '''
 3854    __slots__ = [
 3855        'meta',
 3856        'public_key',
 3857        'rate_limit',
 3858    ]
 3859
 3860    def __init__(
 3861        self,
 3862        meta=None,
 3863        public_key=None,
 3864        rate_limit=None,
 3865    ):
 3866        self.meta = meta if meta is not None else None
 3867        '''
 3868         Reserved for future use.
 3869        '''
 3870        self.public_key = public_key if public_key is not None else ''
 3871        '''
 3872         The public key of the SSH Certificate Authority, in OpenSSH RSA public
 3873         key format.
 3874        '''
 3875        self.rate_limit = rate_limit if rate_limit is not None else None
 3876        '''
 3877         Rate limit information.
 3878        '''
 3879
 3880    def __repr__(self):
 3881        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
 3882            'meta: ' + repr(self.meta) + ' ' +\
 3883            'public_key: ' + repr(self.public_key) + ' ' +\
 3884            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3885            '>'
 3886
 3887    def to_dict(self):
 3888        return {
 3889            'meta': self.meta,
 3890            'public_key': self.public_key,
 3891            'rate_limit': self.rate_limit,
 3892        }
 3893
 3894    @classmethod
 3895    def from_dict(cls, d):
 3896        return cls(
 3897            meta=d.get('meta'),
 3898            public_key=d.get('public_key'),
 3899            rate_limit=d.get('rate_limit'),
 3900        )
 3901
 3902
 3903class ControlPanelVerifyJWTResponse:
 3904    '''
 3905     ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
 3906    '''
 3907    __slots__ = [
 3908        'meta',
 3909        'rate_limit',
 3910        'valid',
 3911    ]
 3912
 3913    def __init__(
 3914        self,
 3915        meta=None,
 3916        rate_limit=None,
 3917        valid=None,
 3918    ):
 3919        self.meta = meta if meta is not None else None
 3920        '''
 3921         Reserved for future use.
 3922        '''
 3923        self.rate_limit = rate_limit if rate_limit is not None else None
 3924        '''
 3925         Rate limit information.
 3926        '''
 3927        self.valid = valid if valid is not None else False
 3928        '''
 3929         Reports if the given token is valid.
 3930        '''
 3931
 3932    def __repr__(self):
 3933        return '<sdm.ControlPanelVerifyJWTResponse ' + \
 3934            'meta: ' + repr(self.meta) + ' ' +\
 3935            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3936            'valid: ' + repr(self.valid) + ' ' +\
 3937            '>'
 3938
 3939    def to_dict(self):
 3940        return {
 3941            'meta': self.meta,
 3942            'rate_limit': self.rate_limit,
 3943            'valid': self.valid,
 3944        }
 3945
 3946    @classmethod
 3947    def from_dict(cls, d):
 3948        return cls(
 3949            meta=d.get('meta'),
 3950            rate_limit=d.get('rate_limit'),
 3951            valid=d.get('valid'),
 3952        )
 3953
 3954
 3955class CreateResponseMetadata:
 3956    '''
 3957     CreateResponseMetadata is reserved for future use.
 3958    '''
 3959    __slots__ = []
 3960
 3961    def __init__(self, ):
 3962        pass
 3963
 3964    def __repr__(self):
 3965        return '<sdm.CreateResponseMetadata ' + \
 3966            '>'
 3967
 3968    def to_dict(self):
 3969        return {}
 3970
 3971    @classmethod
 3972    def from_dict(cls, d):
 3973        return cls()
 3974
 3975
 3976class DB2I:
 3977    '''
 3978
 3979    '''
 3980    __slots__ = [
 3981        'bind_interface',
 3982        'egress_filter',
 3983        'healthy',
 3984        'hostname',
 3985        'id',
 3986        'name',
 3987        'password',
 3988        'port',
 3989        'port_override',
 3990        'secret_store_id',
 3991        'tags',
 3992        'tls_required',
 3993        'username',
 3994    ]
 3995
 3996    def __init__(
 3997        self,
 3998        bind_interface=None,
 3999        egress_filter=None,
 4000        healthy=None,
 4001        hostname=None,
 4002        id=None,
 4003        name=None,
 4004        password=None,
 4005        port=None,
 4006        port_override=None,
 4007        secret_store_id=None,
 4008        tags=None,
 4009        tls_required=None,
 4010        username=None,
 4011    ):
 4012        self.bind_interface = bind_interface if bind_interface is not None else ''
 4013        '''
 4014         Bind interface
 4015        '''
 4016        self.egress_filter = egress_filter if egress_filter is not None else ''
 4017        '''
 4018         A filter applied to the routing logic to pin datasource to nodes.
 4019        '''
 4020        self.healthy = healthy if healthy is not None else False
 4021        '''
 4022         True if the datasource is reachable and the credentials are valid.
 4023        '''
 4024        self.hostname = hostname if hostname is not None else ''
 4025        '''
 4026
 4027        '''
 4028        self.id = id if id is not None else ''
 4029        '''
 4030         Unique identifier of the Resource.
 4031        '''
 4032        self.name = name if name is not None else ''
 4033        '''
 4034         Unique human-readable name of the Resource.
 4035        '''
 4036        self.password = password if password is not None else ''
 4037        '''
 4038
 4039        '''
 4040        self.port = port if port is not None else 0
 4041        '''
 4042
 4043        '''
 4044        self.port_override = port_override if port_override is not None else 0
 4045        '''
 4046
 4047        '''
 4048        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4049        '''
 4050         ID of the secret store containing credentials for this resource, if any.
 4051        '''
 4052        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4053        '''
 4054         Tags is a map of key, value pairs.
 4055        '''
 4056        self.tls_required = tls_required if tls_required is not None else False
 4057        '''
 4058
 4059        '''
 4060        self.username = username if username is not None else ''
 4061        '''
 4062
 4063        '''
 4064
 4065    def __repr__(self):
 4066        return '<sdm.DB2I ' + \
 4067            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4068            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4069            'healthy: ' + repr(self.healthy) + ' ' +\
 4070            'hostname: ' + repr(self.hostname) + ' ' +\
 4071            'id: ' + repr(self.id) + ' ' +\
 4072            'name: ' + repr(self.name) + ' ' +\
 4073            'password: ' + repr(self.password) + ' ' +\
 4074            'port: ' + repr(self.port) + ' ' +\
 4075            'port_override: ' + repr(self.port_override) + ' ' +\
 4076            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4077            'tags: ' + repr(self.tags) + ' ' +\
 4078            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4079            'username: ' + repr(self.username) + ' ' +\
 4080            '>'
 4081
 4082    def to_dict(self):
 4083        return {
 4084            'bind_interface': self.bind_interface,
 4085            'egress_filter': self.egress_filter,
 4086            'healthy': self.healthy,
 4087            'hostname': self.hostname,
 4088            'id': self.id,
 4089            'name': self.name,
 4090            'password': self.password,
 4091            'port': self.port,
 4092            'port_override': self.port_override,
 4093            'secret_store_id': self.secret_store_id,
 4094            'tags': self.tags,
 4095            'tls_required': self.tls_required,
 4096            'username': self.username,
 4097        }
 4098
 4099    @classmethod
 4100    def from_dict(cls, d):
 4101        return cls(
 4102            bind_interface=d.get('bind_interface'),
 4103            egress_filter=d.get('egress_filter'),
 4104            healthy=d.get('healthy'),
 4105            hostname=d.get('hostname'),
 4106            id=d.get('id'),
 4107            name=d.get('name'),
 4108            password=d.get('password'),
 4109            port=d.get('port'),
 4110            port_override=d.get('port_override'),
 4111            secret_store_id=d.get('secret_store_id'),
 4112            tags=d.get('tags'),
 4113            tls_required=d.get('tls_required'),
 4114            username=d.get('username'),
 4115        )
 4116
 4117
 4118class DB2LUW:
 4119    '''
 4120
 4121    '''
 4122    __slots__ = [
 4123        'bind_interface',
 4124        'database',
 4125        'egress_filter',
 4126        'healthy',
 4127        'hostname',
 4128        'id',
 4129        'name',
 4130        'password',
 4131        'port',
 4132        'port_override',
 4133        'secret_store_id',
 4134        'tags',
 4135        'username',
 4136    ]
 4137
 4138    def __init__(
 4139        self,
 4140        bind_interface=None,
 4141        database=None,
 4142        egress_filter=None,
 4143        healthy=None,
 4144        hostname=None,
 4145        id=None,
 4146        name=None,
 4147        password=None,
 4148        port=None,
 4149        port_override=None,
 4150        secret_store_id=None,
 4151        tags=None,
 4152        username=None,
 4153    ):
 4154        self.bind_interface = bind_interface if bind_interface is not None else ''
 4155        '''
 4156         Bind interface
 4157        '''
 4158        self.database = database if database is not None else ''
 4159        '''
 4160
 4161        '''
 4162        self.egress_filter = egress_filter if egress_filter is not None else ''
 4163        '''
 4164         A filter applied to the routing logic to pin datasource to nodes.
 4165        '''
 4166        self.healthy = healthy if healthy is not None else False
 4167        '''
 4168         True if the datasource is reachable and the credentials are valid.
 4169        '''
 4170        self.hostname = hostname if hostname is not None else ''
 4171        '''
 4172
 4173        '''
 4174        self.id = id if id is not None else ''
 4175        '''
 4176         Unique identifier of the Resource.
 4177        '''
 4178        self.name = name if name is not None else ''
 4179        '''
 4180         Unique human-readable name of the Resource.
 4181        '''
 4182        self.password = password if password is not None else ''
 4183        '''
 4184
 4185        '''
 4186        self.port = port if port is not None else 0
 4187        '''
 4188
 4189        '''
 4190        self.port_override = port_override if port_override is not None else 0
 4191        '''
 4192
 4193        '''
 4194        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4195        '''
 4196         ID of the secret store containing credentials for this resource, if any.
 4197        '''
 4198        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4199        '''
 4200         Tags is a map of key, value pairs.
 4201        '''
 4202        self.username = username if username is not None else ''
 4203        '''
 4204
 4205        '''
 4206
 4207    def __repr__(self):
 4208        return '<sdm.DB2LUW ' + \
 4209            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4210            'database: ' + repr(self.database) + ' ' +\
 4211            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4212            'healthy: ' + repr(self.healthy) + ' ' +\
 4213            'hostname: ' + repr(self.hostname) + ' ' +\
 4214            'id: ' + repr(self.id) + ' ' +\
 4215            'name: ' + repr(self.name) + ' ' +\
 4216            'password: ' + repr(self.password) + ' ' +\
 4217            'port: ' + repr(self.port) + ' ' +\
 4218            'port_override: ' + repr(self.port_override) + ' ' +\
 4219            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4220            'tags: ' + repr(self.tags) + ' ' +\
 4221            'username: ' + repr(self.username) + ' ' +\
 4222            '>'
 4223
 4224    def to_dict(self):
 4225        return {
 4226            'bind_interface': self.bind_interface,
 4227            'database': self.database,
 4228            'egress_filter': self.egress_filter,
 4229            'healthy': self.healthy,
 4230            'hostname': self.hostname,
 4231            'id': self.id,
 4232            'name': self.name,
 4233            'password': self.password,
 4234            'port': self.port,
 4235            'port_override': self.port_override,
 4236            'secret_store_id': self.secret_store_id,
 4237            'tags': self.tags,
 4238            'username': self.username,
 4239        }
 4240
 4241    @classmethod
 4242    def from_dict(cls, d):
 4243        return cls(
 4244            bind_interface=d.get('bind_interface'),
 4245            database=d.get('database'),
 4246            egress_filter=d.get('egress_filter'),
 4247            healthy=d.get('healthy'),
 4248            hostname=d.get('hostname'),
 4249            id=d.get('id'),
 4250            name=d.get('name'),
 4251            password=d.get('password'),
 4252            port=d.get('port'),
 4253            port_override=d.get('port_override'),
 4254            secret_store_id=d.get('secret_store_id'),
 4255            tags=d.get('tags'),
 4256            username=d.get('username'),
 4257        )
 4258
 4259
 4260class DeleteResponseMetadata:
 4261    '''
 4262     DeleteResponseMetadata is reserved for future use.
 4263    '''
 4264    __slots__ = []
 4265
 4266    def __init__(self, ):
 4267        pass
 4268
 4269    def __repr__(self):
 4270        return '<sdm.DeleteResponseMetadata ' + \
 4271            '>'
 4272
 4273    def to_dict(self):
 4274        return {}
 4275
 4276    @classmethod
 4277    def from_dict(cls, d):
 4278        return cls()
 4279
 4280
 4281class DocumentDBHost:
 4282    '''
 4283
 4284    '''
 4285    __slots__ = [
 4286        'auth_database',
 4287        'bind_interface',
 4288        'egress_filter',
 4289        'healthy',
 4290        'hostname',
 4291        'id',
 4292        'name',
 4293        'password',
 4294        'port',
 4295        'port_override',
 4296        'secret_store_id',
 4297        'tags',
 4298        'username',
 4299    ]
 4300
 4301    def __init__(
 4302        self,
 4303        auth_database=None,
 4304        bind_interface=None,
 4305        egress_filter=None,
 4306        healthy=None,
 4307        hostname=None,
 4308        id=None,
 4309        name=None,
 4310        password=None,
 4311        port=None,
 4312        port_override=None,
 4313        secret_store_id=None,
 4314        tags=None,
 4315        username=None,
 4316    ):
 4317        self.auth_database = auth_database if auth_database is not None else ''
 4318        '''
 4319
 4320        '''
 4321        self.bind_interface = bind_interface if bind_interface is not None else ''
 4322        '''
 4323         Bind interface
 4324        '''
 4325        self.egress_filter = egress_filter if egress_filter is not None else ''
 4326        '''
 4327         A filter applied to the routing logic to pin datasource to nodes.
 4328        '''
 4329        self.healthy = healthy if healthy is not None else False
 4330        '''
 4331         True if the datasource is reachable and the credentials are valid.
 4332        '''
 4333        self.hostname = hostname if hostname is not None else ''
 4334        '''
 4335
 4336        '''
 4337        self.id = id if id is not None else ''
 4338        '''
 4339         Unique identifier of the Resource.
 4340        '''
 4341        self.name = name if name is not None else ''
 4342        '''
 4343         Unique human-readable name of the Resource.
 4344        '''
 4345        self.password = password if password is not None else ''
 4346        '''
 4347
 4348        '''
 4349        self.port = port if port is not None else 0
 4350        '''
 4351
 4352        '''
 4353        self.port_override = port_override if port_override is not None else 0
 4354        '''
 4355
 4356        '''
 4357        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4358        '''
 4359         ID of the secret store containing credentials for this resource, if any.
 4360        '''
 4361        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4362        '''
 4363         Tags is a map of key, value pairs.
 4364        '''
 4365        self.username = username if username is not None else ''
 4366        '''
 4367
 4368        '''
 4369
 4370    def __repr__(self):
 4371        return '<sdm.DocumentDBHost ' + \
 4372            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4373            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4374            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4375            'healthy: ' + repr(self.healthy) + ' ' +\
 4376            'hostname: ' + repr(self.hostname) + ' ' +\
 4377            'id: ' + repr(self.id) + ' ' +\
 4378            'name: ' + repr(self.name) + ' ' +\
 4379            'password: ' + repr(self.password) + ' ' +\
 4380            'port: ' + repr(self.port) + ' ' +\
 4381            'port_override: ' + repr(self.port_override) + ' ' +\
 4382            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4383            'tags: ' + repr(self.tags) + ' ' +\
 4384            'username: ' + repr(self.username) + ' ' +\
 4385            '>'
 4386
 4387    def to_dict(self):
 4388        return {
 4389            'auth_database': self.auth_database,
 4390            'bind_interface': self.bind_interface,
 4391            'egress_filter': self.egress_filter,
 4392            'healthy': self.healthy,
 4393            'hostname': self.hostname,
 4394            'id': self.id,
 4395            'name': self.name,
 4396            'password': self.password,
 4397            'port': self.port,
 4398            'port_override': self.port_override,
 4399            'secret_store_id': self.secret_store_id,
 4400            'tags': self.tags,
 4401            'username': self.username,
 4402        }
 4403
 4404    @classmethod
 4405    def from_dict(cls, d):
 4406        return cls(
 4407            auth_database=d.get('auth_database'),
 4408            bind_interface=d.get('bind_interface'),
 4409            egress_filter=d.get('egress_filter'),
 4410            healthy=d.get('healthy'),
 4411            hostname=d.get('hostname'),
 4412            id=d.get('id'),
 4413            name=d.get('name'),
 4414            password=d.get('password'),
 4415            port=d.get('port'),
 4416            port_override=d.get('port_override'),
 4417            secret_store_id=d.get('secret_store_id'),
 4418            tags=d.get('tags'),
 4419            username=d.get('username'),
 4420        )
 4421
 4422
 4423class DocumentDBReplicaSet:
 4424    '''
 4425
 4426    '''
 4427    __slots__ = [
 4428        'auth_database',
 4429        'bind_interface',
 4430        'connect_to_replica',
 4431        'egress_filter',
 4432        'healthy',
 4433        'hostname',
 4434        'id',
 4435        'name',
 4436        'password',
 4437        'port_override',
 4438        'replica_set',
 4439        'secret_store_id',
 4440        'tags',
 4441        'username',
 4442    ]
 4443
 4444    def __init__(
 4445        self,
 4446        auth_database=None,
 4447        bind_interface=None,
 4448        connect_to_replica=None,
 4449        egress_filter=None,
 4450        healthy=None,
 4451        hostname=None,
 4452        id=None,
 4453        name=None,
 4454        password=None,
 4455        port_override=None,
 4456        replica_set=None,
 4457        secret_store_id=None,
 4458        tags=None,
 4459        username=None,
 4460    ):
 4461        self.auth_database = auth_database if auth_database is not None else ''
 4462        '''
 4463
 4464        '''
 4465        self.bind_interface = bind_interface if bind_interface is not None else ''
 4466        '''
 4467         Bind interface
 4468        '''
 4469        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 4470        '''
 4471
 4472        '''
 4473        self.egress_filter = egress_filter if egress_filter is not None else ''
 4474        '''
 4475         A filter applied to the routing logic to pin datasource to nodes.
 4476        '''
 4477        self.healthy = healthy if healthy is not None else False
 4478        '''
 4479         True if the datasource is reachable and the credentials are valid.
 4480        '''
 4481        self.hostname = hostname if hostname is not None else ''
 4482        '''
 4483         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
 4484        '''
 4485        self.id = id if id is not None else ''
 4486        '''
 4487         Unique identifier of the Resource.
 4488        '''
 4489        self.name = name if name is not None else ''
 4490        '''
 4491         Unique human-readable name of the Resource.
 4492        '''
 4493        self.password = password if password is not None else ''
 4494        '''
 4495
 4496        '''
 4497        self.port_override = port_override if port_override is not None else 0
 4498        '''
 4499
 4500        '''
 4501        self.replica_set = replica_set if replica_set is not None else ''
 4502        '''
 4503
 4504        '''
 4505        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4506        '''
 4507         ID of the secret store containing credentials for this resource, if any.
 4508        '''
 4509        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4510        '''
 4511         Tags is a map of key, value pairs.
 4512        '''
 4513        self.username = username if username is not None else ''
 4514        '''
 4515
 4516        '''
 4517
 4518    def __repr__(self):
 4519        return '<sdm.DocumentDBReplicaSet ' + \
 4520            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4521            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4522            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 4523            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4524            'healthy: ' + repr(self.healthy) + ' ' +\
 4525            'hostname: ' + repr(self.hostname) + ' ' +\
 4526            'id: ' + repr(self.id) + ' ' +\
 4527            'name: ' + repr(self.name) + ' ' +\
 4528            'password: ' + repr(self.password) + ' ' +\
 4529            'port_override: ' + repr(self.port_override) + ' ' +\
 4530            'replica_set: ' + repr(self.replica_set) + ' ' +\
 4531            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4532            'tags: ' + repr(self.tags) + ' ' +\
 4533            'username: ' + repr(self.username) + ' ' +\
 4534            '>'
 4535
 4536    def to_dict(self):
 4537        return {
 4538            'auth_database': self.auth_database,
 4539            'bind_interface': self.bind_interface,
 4540            'connect_to_replica': self.connect_to_replica,
 4541            'egress_filter': self.egress_filter,
 4542            'healthy': self.healthy,
 4543            'hostname': self.hostname,
 4544            'id': self.id,
 4545            'name': self.name,
 4546            'password': self.password,
 4547            'port_override': self.port_override,
 4548            'replica_set': self.replica_set,
 4549            'secret_store_id': self.secret_store_id,
 4550            'tags': self.tags,
 4551            'username': self.username,
 4552        }
 4553
 4554    @classmethod
 4555    def from_dict(cls, d):
 4556        return cls(
 4557            auth_database=d.get('auth_database'),
 4558            bind_interface=d.get('bind_interface'),
 4559            connect_to_replica=d.get('connect_to_replica'),
 4560            egress_filter=d.get('egress_filter'),
 4561            healthy=d.get('healthy'),
 4562            hostname=d.get('hostname'),
 4563            id=d.get('id'),
 4564            name=d.get('name'),
 4565            password=d.get('password'),
 4566            port_override=d.get('port_override'),
 4567            replica_set=d.get('replica_set'),
 4568            secret_store_id=d.get('secret_store_id'),
 4569            tags=d.get('tags'),
 4570            username=d.get('username'),
 4571        )
 4572
 4573
 4574class Druid:
 4575    '''
 4576
 4577    '''
 4578    __slots__ = [
 4579        'bind_interface',
 4580        'egress_filter',
 4581        'healthy',
 4582        'hostname',
 4583        'id',
 4584        'name',
 4585        'password',
 4586        'port',
 4587        'port_override',
 4588        'secret_store_id',
 4589        'tags',
 4590        'username',
 4591    ]
 4592
 4593    def __init__(
 4594        self,
 4595        bind_interface=None,
 4596        egress_filter=None,
 4597        healthy=None,
 4598        hostname=None,
 4599        id=None,
 4600        name=None,
 4601        password=None,
 4602        port=None,
 4603        port_override=None,
 4604        secret_store_id=None,
 4605        tags=None,
 4606        username=None,
 4607    ):
 4608        self.bind_interface = bind_interface if bind_interface is not None else ''
 4609        '''
 4610         Bind interface
 4611        '''
 4612        self.egress_filter = egress_filter if egress_filter is not None else ''
 4613        '''
 4614         A filter applied to the routing logic to pin datasource to nodes.
 4615        '''
 4616        self.healthy = healthy if healthy is not None else False
 4617        '''
 4618         True if the datasource is reachable and the credentials are valid.
 4619        '''
 4620        self.hostname = hostname if hostname is not None else ''
 4621        '''
 4622
 4623        '''
 4624        self.id = id if id is not None else ''
 4625        '''
 4626         Unique identifier of the Resource.
 4627        '''
 4628        self.name = name if name is not None else ''
 4629        '''
 4630         Unique human-readable name of the Resource.
 4631        '''
 4632        self.password = password if password is not None else ''
 4633        '''
 4634
 4635        '''
 4636        self.port = port if port is not None else 0
 4637        '''
 4638
 4639        '''
 4640        self.port_override = port_override if port_override is not None else 0
 4641        '''
 4642
 4643        '''
 4644        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4645        '''
 4646         ID of the secret store containing credentials for this resource, if any.
 4647        '''
 4648        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4649        '''
 4650         Tags is a map of key, value pairs.
 4651        '''
 4652        self.username = username if username is not None else ''
 4653        '''
 4654
 4655        '''
 4656
 4657    def __repr__(self):
 4658        return '<sdm.Druid ' + \
 4659            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4660            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4661            'healthy: ' + repr(self.healthy) + ' ' +\
 4662            'hostname: ' + repr(self.hostname) + ' ' +\
 4663            'id: ' + repr(self.id) + ' ' +\
 4664            'name: ' + repr(self.name) + ' ' +\
 4665            'password: ' + repr(self.password) + ' ' +\
 4666            'port: ' + repr(self.port) + ' ' +\
 4667            'port_override: ' + repr(self.port_override) + ' ' +\
 4668            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4669            'tags: ' + repr(self.tags) + ' ' +\
 4670            'username: ' + repr(self.username) + ' ' +\
 4671            '>'
 4672
 4673    def to_dict(self):
 4674        return {
 4675            'bind_interface': self.bind_interface,
 4676            'egress_filter': self.egress_filter,
 4677            'healthy': self.healthy,
 4678            'hostname': self.hostname,
 4679            'id': self.id,
 4680            'name': self.name,
 4681            'password': self.password,
 4682            'port': self.port,
 4683            'port_override': self.port_override,
 4684            'secret_store_id': self.secret_store_id,
 4685            'tags': self.tags,
 4686            'username': self.username,
 4687        }
 4688
 4689    @classmethod
 4690    def from_dict(cls, d):
 4691        return cls(
 4692            bind_interface=d.get('bind_interface'),
 4693            egress_filter=d.get('egress_filter'),
 4694            healthy=d.get('healthy'),
 4695            hostname=d.get('hostname'),
 4696            id=d.get('id'),
 4697            name=d.get('name'),
 4698            password=d.get('password'),
 4699            port=d.get('port'),
 4700            port_override=d.get('port_override'),
 4701            secret_store_id=d.get('secret_store_id'),
 4702            tags=d.get('tags'),
 4703            username=d.get('username'),
 4704        )
 4705
 4706
 4707class DynamoDB:
 4708    '''
 4709
 4710    '''
 4711    __slots__ = [
 4712        'access_key',
 4713        'bind_interface',
 4714        'egress_filter',
 4715        'endpoint',
 4716        'healthy',
 4717        'id',
 4718        'name',
 4719        'port_override',
 4720        'region',
 4721        'role_arn',
 4722        'role_external_id',
 4723        'secret_access_key',
 4724        'secret_store_id',
 4725        'tags',
 4726    ]
 4727
 4728    def __init__(
 4729        self,
 4730        access_key=None,
 4731        bind_interface=None,
 4732        egress_filter=None,
 4733        endpoint=None,
 4734        healthy=None,
 4735        id=None,
 4736        name=None,
 4737        port_override=None,
 4738        region=None,
 4739        role_arn=None,
 4740        role_external_id=None,
 4741        secret_access_key=None,
 4742        secret_store_id=None,
 4743        tags=None,
 4744    ):
 4745        self.access_key = access_key if access_key is not None else ''
 4746        '''
 4747
 4748        '''
 4749        self.bind_interface = bind_interface if bind_interface is not None else ''
 4750        '''
 4751         Bind interface
 4752        '''
 4753        self.egress_filter = egress_filter if egress_filter is not None else ''
 4754        '''
 4755         A filter applied to the routing logic to pin datasource to nodes.
 4756        '''
 4757        self.endpoint = endpoint if endpoint is not None else ''
 4758        '''
 4759
 4760        '''
 4761        self.healthy = healthy if healthy is not None else False
 4762        '''
 4763         True if the datasource is reachable and the credentials are valid.
 4764        '''
 4765        self.id = id if id is not None else ''
 4766        '''
 4767         Unique identifier of the Resource.
 4768        '''
 4769        self.name = name if name is not None else ''
 4770        '''
 4771         Unique human-readable name of the Resource.
 4772        '''
 4773        self.port_override = port_override if port_override is not None else 0
 4774        '''
 4775
 4776        '''
 4777        self.region = region if region is not None else ''
 4778        '''
 4779
 4780        '''
 4781        self.role_arn = role_arn if role_arn is not None else ''
 4782        '''
 4783
 4784        '''
 4785        self.role_external_id = role_external_id if role_external_id is not None else ''
 4786        '''
 4787
 4788        '''
 4789        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 4790        '''
 4791
 4792        '''
 4793        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4794        '''
 4795         ID of the secret store containing credentials for this resource, if any.
 4796        '''
 4797        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4798        '''
 4799         Tags is a map of key, value pairs.
 4800        '''
 4801
 4802    def __repr__(self):
 4803        return '<sdm.DynamoDB ' + \
 4804            'access_key: ' + repr(self.access_key) + ' ' +\
 4805            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4806            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4807            'endpoint: ' + repr(self.endpoint) + ' ' +\
 4808            'healthy: ' + repr(self.healthy) + ' ' +\
 4809            'id: ' + repr(self.id) + ' ' +\
 4810            'name: ' + repr(self.name) + ' ' +\
 4811            'port_override: ' + repr(self.port_override) + ' ' +\
 4812            'region: ' + repr(self.region) + ' ' +\
 4813            'role_arn: ' + repr(self.role_arn) + ' ' +\
 4814            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 4815            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 4816            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4817            'tags: ' + repr(self.tags) + ' ' +\
 4818            '>'
 4819
 4820    def to_dict(self):
 4821        return {
 4822            'access_key': self.access_key,
 4823            'bind_interface': self.bind_interface,
 4824            'egress_filter': self.egress_filter,
 4825            'endpoint': self.endpoint,
 4826            'healthy': self.healthy,
 4827            'id': self.id,
 4828            'name': self.name,
 4829            'port_override': self.port_override,
 4830            'region': self.region,
 4831            'role_arn': self.role_arn,
 4832            'role_external_id': self.role_external_id,
 4833            'secret_access_key': self.secret_access_key,
 4834            'secret_store_id': self.secret_store_id,
 4835            'tags': self.tags,
 4836        }
 4837
 4838    @classmethod
 4839    def from_dict(cls, d):
 4840        return cls(
 4841            access_key=d.get('access_key'),
 4842            bind_interface=d.get('bind_interface'),
 4843            egress_filter=d.get('egress_filter'),
 4844            endpoint=d.get('endpoint'),
 4845            healthy=d.get('healthy'),
 4846            id=d.get('id'),
 4847            name=d.get('name'),
 4848            port_override=d.get('port_override'),
 4849            region=d.get('region'),
 4850            role_arn=d.get('role_arn'),
 4851            role_external_id=d.get('role_external_id'),
 4852            secret_access_key=d.get('secret_access_key'),
 4853            secret_store_id=d.get('secret_store_id'),
 4854            tags=d.get('tags'),
 4855        )
 4856
 4857
 4858class Elastic:
 4859    '''
 4860
 4861    '''
 4862    __slots__ = [
 4863        'bind_interface',
 4864        'egress_filter',
 4865        'healthy',
 4866        'hostname',
 4867        'id',
 4868        'name',
 4869        'password',
 4870        'port',
 4871        'port_override',
 4872        'secret_store_id',
 4873        'tags',
 4874        'tls_required',
 4875        'username',
 4876    ]
 4877
 4878    def __init__(
 4879        self,
 4880        bind_interface=None,
 4881        egress_filter=None,
 4882        healthy=None,
 4883        hostname=None,
 4884        id=None,
 4885        name=None,
 4886        password=None,
 4887        port=None,
 4888        port_override=None,
 4889        secret_store_id=None,
 4890        tags=None,
 4891        tls_required=None,
 4892        username=None,
 4893    ):
 4894        self.bind_interface = bind_interface if bind_interface is not None else ''
 4895        '''
 4896         Bind interface
 4897        '''
 4898        self.egress_filter = egress_filter if egress_filter is not None else ''
 4899        '''
 4900         A filter applied to the routing logic to pin datasource to nodes.
 4901        '''
 4902        self.healthy = healthy if healthy is not None else False
 4903        '''
 4904         True if the datasource is reachable and the credentials are valid.
 4905        '''
 4906        self.hostname = hostname if hostname is not None else ''
 4907        '''
 4908
 4909        '''
 4910        self.id = id if id is not None else ''
 4911        '''
 4912         Unique identifier of the Resource.
 4913        '''
 4914        self.name = name if name is not None else ''
 4915        '''
 4916         Unique human-readable name of the Resource.
 4917        '''
 4918        self.password = password if password is not None else ''
 4919        '''
 4920
 4921        '''
 4922        self.port = port if port is not None else 0
 4923        '''
 4924
 4925        '''
 4926        self.port_override = port_override if port_override is not None else 0
 4927        '''
 4928
 4929        '''
 4930        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4931        '''
 4932         ID of the secret store containing credentials for this resource, if any.
 4933        '''
 4934        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4935        '''
 4936         Tags is a map of key, value pairs.
 4937        '''
 4938        self.tls_required = tls_required if tls_required is not None else False
 4939        '''
 4940
 4941        '''
 4942        self.username = username if username is not None else ''
 4943        '''
 4944
 4945        '''
 4946
 4947    def __repr__(self):
 4948        return '<sdm.Elastic ' + \
 4949            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4950            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4951            'healthy: ' + repr(self.healthy) + ' ' +\
 4952            'hostname: ' + repr(self.hostname) + ' ' +\
 4953            'id: ' + repr(self.id) + ' ' +\
 4954            'name: ' + repr(self.name) + ' ' +\
 4955            'password: ' + repr(self.password) + ' ' +\
 4956            'port: ' + repr(self.port) + ' ' +\
 4957            'port_override: ' + repr(self.port_override) + ' ' +\
 4958            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4959            'tags: ' + repr(self.tags) + ' ' +\
 4960            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4961            'username: ' + repr(self.username) + ' ' +\
 4962            '>'
 4963
 4964    def to_dict(self):
 4965        return {
 4966            'bind_interface': self.bind_interface,
 4967            'egress_filter': self.egress_filter,
 4968            'healthy': self.healthy,
 4969            'hostname': self.hostname,
 4970            'id': self.id,
 4971            'name': self.name,
 4972            'password': self.password,
 4973            'port': self.port,
 4974            'port_override': self.port_override,
 4975            'secret_store_id': self.secret_store_id,
 4976            'tags': self.tags,
 4977            'tls_required': self.tls_required,
 4978            'username': self.username,
 4979        }
 4980
 4981    @classmethod
 4982    def from_dict(cls, d):
 4983        return cls(
 4984            bind_interface=d.get('bind_interface'),
 4985            egress_filter=d.get('egress_filter'),
 4986            healthy=d.get('healthy'),
 4987            hostname=d.get('hostname'),
 4988            id=d.get('id'),
 4989            name=d.get('name'),
 4990            password=d.get('password'),
 4991            port=d.get('port'),
 4992            port_override=d.get('port_override'),
 4993            secret_store_id=d.get('secret_store_id'),
 4994            tags=d.get('tags'),
 4995            tls_required=d.get('tls_required'),
 4996            username=d.get('username'),
 4997        )
 4998
 4999
 5000class ElasticacheRedis:
 5001    '''
 5002
 5003    '''
 5004    __slots__ = [
 5005        'bind_interface',
 5006        'egress_filter',
 5007        'healthy',
 5008        'hostname',
 5009        'id',
 5010        'name',
 5011        'password',
 5012        'port',
 5013        'port_override',
 5014        'secret_store_id',
 5015        'tags',
 5016        'tls_required',
 5017    ]
 5018
 5019    def __init__(
 5020        self,
 5021        bind_interface=None,
 5022        egress_filter=None,
 5023        healthy=None,
 5024        hostname=None,
 5025        id=None,
 5026        name=None,
 5027        password=None,
 5028        port=None,
 5029        port_override=None,
 5030        secret_store_id=None,
 5031        tags=None,
 5032        tls_required=None,
 5033    ):
 5034        self.bind_interface = bind_interface if bind_interface is not None else ''
 5035        '''
 5036         Bind interface
 5037        '''
 5038        self.egress_filter = egress_filter if egress_filter is not None else ''
 5039        '''
 5040         A filter applied to the routing logic to pin datasource to nodes.
 5041        '''
 5042        self.healthy = healthy if healthy is not None else False
 5043        '''
 5044         True if the datasource is reachable and the credentials are valid.
 5045        '''
 5046        self.hostname = hostname if hostname is not None else ''
 5047        '''
 5048
 5049        '''
 5050        self.id = id if id is not None else ''
 5051        '''
 5052         Unique identifier of the Resource.
 5053        '''
 5054        self.name = name if name is not None else ''
 5055        '''
 5056         Unique human-readable name of the Resource.
 5057        '''
 5058        self.password = password if password is not None else ''
 5059        '''
 5060
 5061        '''
 5062        self.port = port if port is not None else 0
 5063        '''
 5064
 5065        '''
 5066        self.port_override = port_override if port_override is not None else 0
 5067        '''
 5068
 5069        '''
 5070        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5071        '''
 5072         ID of the secret store containing credentials for this resource, if any.
 5073        '''
 5074        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5075        '''
 5076         Tags is a map of key, value pairs.
 5077        '''
 5078        self.tls_required = tls_required if tls_required is not None else False
 5079        '''
 5080
 5081        '''
 5082
 5083    def __repr__(self):
 5084        return '<sdm.ElasticacheRedis ' + \
 5085            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5086            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5087            'healthy: ' + repr(self.healthy) + ' ' +\
 5088            'hostname: ' + repr(self.hostname) + ' ' +\
 5089            'id: ' + repr(self.id) + ' ' +\
 5090            'name: ' + repr(self.name) + ' ' +\
 5091            'password: ' + repr(self.password) + ' ' +\
 5092            'port: ' + repr(self.port) + ' ' +\
 5093            'port_override: ' + repr(self.port_override) + ' ' +\
 5094            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5095            'tags: ' + repr(self.tags) + ' ' +\
 5096            'tls_required: ' + repr(self.tls_required) + ' ' +\
 5097            '>'
 5098
 5099    def to_dict(self):
 5100        return {
 5101            'bind_interface': self.bind_interface,
 5102            'egress_filter': self.egress_filter,
 5103            'healthy': self.healthy,
 5104            'hostname': self.hostname,
 5105            'id': self.id,
 5106            'name': self.name,
 5107            'password': self.password,
 5108            'port': self.port,
 5109            'port_override': self.port_override,
 5110            'secret_store_id': self.secret_store_id,
 5111            'tags': self.tags,
 5112            'tls_required': self.tls_required,
 5113        }
 5114
 5115    @classmethod
 5116    def from_dict(cls, d):
 5117        return cls(
 5118            bind_interface=d.get('bind_interface'),
 5119            egress_filter=d.get('egress_filter'),
 5120            healthy=d.get('healthy'),
 5121            hostname=d.get('hostname'),
 5122            id=d.get('id'),
 5123            name=d.get('name'),
 5124            password=d.get('password'),
 5125            port=d.get('port'),
 5126            port_override=d.get('port_override'),
 5127            secret_store_id=d.get('secret_store_id'),
 5128            tags=d.get('tags'),
 5129            tls_required=d.get('tls_required'),
 5130        )
 5131
 5132
 5133class GCP:
 5134    '''
 5135
 5136    '''
 5137    __slots__ = [
 5138        'bind_interface',
 5139        'egress_filter',
 5140        'healthy',
 5141        'id',
 5142        'keyfile',
 5143        'name',
 5144        'scopes',
 5145        'secret_store_id',
 5146        'tags',
 5147    ]
 5148
 5149    def __init__(
 5150        self,
 5151        bind_interface=None,
 5152        egress_filter=None,
 5153        healthy=None,
 5154        id=None,
 5155        keyfile=None,
 5156        name=None,
 5157        scopes=None,
 5158        secret_store_id=None,
 5159        tags=None,
 5160    ):
 5161        self.bind_interface = bind_interface if bind_interface is not None else ''
 5162        '''
 5163         Bind interface
 5164        '''
 5165        self.egress_filter = egress_filter if egress_filter is not None else ''
 5166        '''
 5167         A filter applied to the routing logic to pin datasource to nodes.
 5168        '''
 5169        self.healthy = healthy if healthy is not None else False
 5170        '''
 5171         True if the datasource is reachable and the credentials are valid.
 5172        '''
 5173        self.id = id if id is not None else ''
 5174        '''
 5175         Unique identifier of the Resource.
 5176        '''
 5177        self.keyfile = keyfile if keyfile is not None else ''
 5178        '''
 5179
 5180        '''
 5181        self.name = name if name is not None else ''
 5182        '''
 5183         Unique human-readable name of the Resource.
 5184        '''
 5185        self.scopes = scopes if scopes is not None else ''
 5186        '''
 5187
 5188        '''
 5189        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5190        '''
 5191         ID of the secret store containing credentials for this resource, if any.
 5192        '''
 5193        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5194        '''
 5195         Tags is a map of key, value pairs.
 5196        '''
 5197
 5198    def __repr__(self):
 5199        return '<sdm.GCP ' + \
 5200            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5201            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5202            'healthy: ' + repr(self.healthy) + ' ' +\
 5203            'id: ' + repr(self.id) + ' ' +\
 5204            'keyfile: ' + repr(self.keyfile) + ' ' +\
 5205            'name: ' + repr(self.name) + ' ' +\
 5206            'scopes: ' + repr(self.scopes) + ' ' +\
 5207            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5208            'tags: ' + repr(self.tags) + ' ' +\
 5209            '>'
 5210
 5211    def to_dict(self):
 5212        return {
 5213            'bind_interface': self.bind_interface,
 5214            'egress_filter': self.egress_filter,
 5215            'healthy': self.healthy,
 5216            'id': self.id,
 5217            'keyfile': self.keyfile,
 5218            'name': self.name,
 5219            'scopes': self.scopes,
 5220            'secret_store_id': self.secret_store_id,
 5221            'tags': self.tags,
 5222        }
 5223
 5224    @classmethod
 5225    def from_dict(cls, d):
 5226        return cls(
 5227            bind_interface=d.get('bind_interface'),
 5228            egress_filter=d.get('egress_filter'),
 5229            healthy=d.get('healthy'),
 5230            id=d.get('id'),
 5231            keyfile=d.get('keyfile'),
 5232            name=d.get('name'),
 5233            scopes=d.get('scopes'),
 5234            secret_store_id=d.get('secret_store_id'),
 5235            tags=d.get('tags'),
 5236        )
 5237
 5238
 5239class GCPStore:
 5240    '''
 5241
 5242    '''
 5243    __slots__ = [
 5244        'id',
 5245        'name',
 5246        'projectid',
 5247        'tags',
 5248    ]
 5249
 5250    def __init__(
 5251        self,
 5252        id=None,
 5253        name=None,
 5254        projectid=None,
 5255        tags=None,
 5256    ):
 5257        self.id = id if id is not None else ''
 5258        '''
 5259         Unique identifier of the SecretStore.
 5260        '''
 5261        self.name = name if name is not None else ''
 5262        '''
 5263         Unique human-readable name of the SecretStore.
 5264        '''
 5265        self.projectid = projectid if projectid is not None else ''
 5266        '''
 5267
 5268        '''
 5269        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5270        '''
 5271         Tags is a map of key, value pairs.
 5272        '''
 5273
 5274    def __repr__(self):
 5275        return '<sdm.GCPStore ' + \
 5276            'id: ' + repr(self.id) + ' ' +\
 5277            'name: ' + repr(self.name) + ' ' +\
 5278            'projectid: ' + repr(self.projectid) + ' ' +\
 5279            'tags: ' + repr(self.tags) + ' ' +\
 5280            '>'
 5281
 5282    def to_dict(self):
 5283        return {
 5284            'id': self.id,
 5285            'name': self.name,
 5286            'projectid': self.projectid,
 5287            'tags': self.tags,
 5288        }
 5289
 5290    @classmethod
 5291    def from_dict(cls, d):
 5292        return cls(
 5293            id=d.get('id'),
 5294            name=d.get('name'),
 5295            projectid=d.get('projectid'),
 5296            tags=d.get('tags'),
 5297        )
 5298
 5299
 5300class Gateway:
 5301    '''
 5302     Gateway represents a StrongDM CLI installation running in gateway mode.
 5303    '''
 5304    __slots__ = [
 5305        'bind_address',
 5306        'gateway_filter',
 5307        'id',
 5308        'listen_address',
 5309        'name',
 5310        'state',
 5311        'tags',
 5312    ]
 5313
 5314    def __init__(
 5315        self,
 5316        bind_address=None,
 5317        gateway_filter=None,
 5318        id=None,
 5319        listen_address=None,
 5320        name=None,
 5321        state=None,
 5322        tags=None,
 5323    ):
 5324        self.bind_address = bind_address if bind_address is not None else ''
 5325        '''
 5326         The hostname/port tuple which the gateway daemon will bind to.
 5327         If not provided on create, set to "0.0.0.0:listen_address_port".
 5328        '''
 5329        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 5330        '''
 5331         GatewayFilter can be used to restrict the peering between relays and
 5332         gateways.
 5333        '''
 5334        self.id = id if id is not None else ''
 5335        '''
 5336         Unique identifier of the Gateway.
 5337        '''
 5338        self.listen_address = listen_address if listen_address is not None else ''
 5339        '''
 5340         The public hostname/port tuple at which the gateway will be accessible to clients.
 5341        '''
 5342        self.name = name if name is not None else ''
 5343        '''
 5344         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 5345        '''
 5346        self.state = state if state is not None else ''
 5347        '''
 5348         The current state of the gateway. One of: "new", "verifying_restart",
 5349         "restarting", "started", "stopped", "dead", "unknown"
 5350        '''
 5351        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5352        '''
 5353         Tags is a map of key, value pairs.
 5354        '''
 5355
 5356    def __repr__(self):
 5357        return '<sdm.Gateway ' + \
 5358            'bind_address: ' + repr(self.bind_address) + ' ' +\
 5359            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 5360            'id: ' + repr(self.id) + ' ' +\
 5361            'listen_address: ' + repr(self.listen_address) + ' ' +\
 5362            'name: ' + repr(self.name) + ' ' +\
 5363            'state: ' + repr(self.state) + ' ' +\
 5364            'tags: ' + repr(self.tags) + ' ' +\
 5365            '>'
 5366
 5367    def to_dict(self):
 5368        return {
 5369            'bind_address': self.bind_address,
 5370            'gateway_filter': self.gateway_filter,
 5371            'id': self.id,
 5372            'listen_address': self.listen_address,
 5373            'name': self.name,
 5374            'state': self.state,
 5375            'tags': self.tags,
 5376        }
 5377
 5378    @classmethod
 5379    def from_dict(cls, d):
 5380        return cls(
 5381            bind_address=d.get('bind_address'),
 5382            gateway_filter=d.get('gateway_filter'),
 5383            id=d.get('id'),
 5384            listen_address=d.get('listen_address'),
 5385            name=d.get('name'),
 5386            state=d.get('state'),
 5387            tags=d.get('tags'),
 5388        )
 5389
 5390
 5391class GetResponseMetadata:
 5392    '''
 5393     GetResponseMetadata is reserved for future use.
 5394    '''
 5395    __slots__ = []
 5396
 5397    def __init__(self, ):
 5398        pass
 5399
 5400    def __repr__(self):
 5401        return '<sdm.GetResponseMetadata ' + \
 5402            '>'
 5403
 5404    def to_dict(self):
 5405        return {}
 5406
 5407    @classmethod
 5408    def from_dict(cls, d):
 5409        return cls()
 5410
 5411
 5412class GoogleGKE:
 5413    '''
 5414
 5415    '''
 5416    __slots__ = [
 5417        'bind_interface',
 5418        'certificate_authority',
 5419        'egress_filter',
 5420        'endpoint',
 5421        'healthcheck_namespace',
 5422        'healthy',
 5423        'id',
 5424        'name',
 5425        'remote_identity_group_id',
 5426        'remote_identity_healthcheck_username',
 5427        'secret_store_id',
 5428        'service_account_key',
 5429        'tags',
 5430    ]
 5431
 5432    def __init__(
 5433        self,
 5434        bind_interface=None,
 5435        certificate_authority=None,
 5436        egress_filter=None,
 5437        endpoint=None,
 5438        healthcheck_namespace=None,
 5439        healthy=None,
 5440        id=None,
 5441        name=None,
 5442        remote_identity_group_id=None,
 5443        remote_identity_healthcheck_username=None,
 5444        secret_store_id=None,
 5445        service_account_key=None,
 5446        tags=None,
 5447    ):
 5448        self.bind_interface = bind_interface if bind_interface is not None else ''
 5449        '''
 5450         Bind interface
 5451        '''
 5452        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5453        '''
 5454
 5455        '''
 5456        self.egress_filter = egress_filter if egress_filter is not None else ''
 5457        '''
 5458         A filter applied to the routing logic to pin datasource to nodes.
 5459        '''
 5460        self.endpoint = endpoint if endpoint is not None else ''
 5461        '''
 5462
 5463        '''
 5464        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5465        '''
 5466         The path used to check the health of your connection.  Defaults to `default`.
 5467        '''
 5468        self.healthy = healthy if healthy is not None else False
 5469        '''
 5470         True if the datasource is reachable and the credentials are valid.
 5471        '''
 5472        self.id = id if id is not None else ''
 5473        '''
 5474         Unique identifier of the Resource.
 5475        '''
 5476        self.name = name if name is not None else ''
 5477        '''
 5478         Unique human-readable name of the Resource.
 5479        '''
 5480        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 5481        '''
 5482
 5483        '''
 5484        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 5485        '''
 5486
 5487        '''
 5488        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5489        '''
 5490         ID of the secret store containing credentials for this resource, if any.
 5491        '''
 5492        self.service_account_key = service_account_key if service_account_key is not None else ''
 5493        '''
 5494
 5495        '''
 5496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5497        '''
 5498         Tags is a map of key, value pairs.
 5499        '''
 5500
 5501    def __repr__(self):
 5502        return '<sdm.GoogleGKE ' + \
 5503            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5504            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5505            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5506            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5507            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5508            'healthy: ' + repr(self.healthy) + ' ' +\
 5509            'id: ' + repr(self.id) + ' ' +\
 5510            'name: ' + repr(self.name) + ' ' +\
 5511            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 5512            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 5513            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5514            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5515            'tags: ' + repr(self.tags) + ' ' +\
 5516            '>'
 5517
 5518    def to_dict(self):
 5519        return {
 5520            'bind_interface': self.bind_interface,
 5521            'certificate_authority': self.certificate_authority,
 5522            'egress_filter': self.egress_filter,
 5523            'endpoint': self.endpoint,
 5524            'healthcheck_namespace': self.healthcheck_namespace,
 5525            'healthy': self.healthy,
 5526            'id': self.id,
 5527            'name': self.name,
 5528            'remote_identity_group_id': self.remote_identity_group_id,
 5529            'remote_identity_healthcheck_username':
 5530            self.remote_identity_healthcheck_username,
 5531            'secret_store_id': self.secret_store_id,
 5532            'service_account_key': self.service_account_key,
 5533            'tags': self.tags,
 5534        }
 5535
 5536    @classmethod
 5537    def from_dict(cls, d):
 5538        return cls(
 5539            bind_interface=d.get('bind_interface'),
 5540            certificate_authority=d.get('certificate_authority'),
 5541            egress_filter=d.get('egress_filter'),
 5542            endpoint=d.get('endpoint'),
 5543            healthcheck_namespace=d.get('healthcheck_namespace'),
 5544            healthy=d.get('healthy'),
 5545            id=d.get('id'),
 5546            name=d.get('name'),
 5547            remote_identity_group_id=d.get('remote_identity_group_id'),
 5548            remote_identity_healthcheck_username=d.get(
 5549                'remote_identity_healthcheck_username'),
 5550            secret_store_id=d.get('secret_store_id'),
 5551            service_account_key=d.get('service_account_key'),
 5552            tags=d.get('tags'),
 5553        )
 5554
 5555
 5556class GoogleGKEUserImpersonation:
 5557    '''
 5558
 5559    '''
 5560    __slots__ = [
 5561        'bind_interface',
 5562        'certificate_authority',
 5563        'egress_filter',
 5564        'endpoint',
 5565        'healthcheck_namespace',
 5566        'healthy',
 5567        'id',
 5568        'name',
 5569        'secret_store_id',
 5570        'service_account_key',
 5571        'tags',
 5572    ]
 5573
 5574    def __init__(
 5575        self,
 5576        bind_interface=None,
 5577        certificate_authority=None,
 5578        egress_filter=None,
 5579        endpoint=None,
 5580        healthcheck_namespace=None,
 5581        healthy=None,
 5582        id=None,
 5583        name=None,
 5584        secret_store_id=None,
 5585        service_account_key=None,
 5586        tags=None,
 5587    ):
 5588        self.bind_interface = bind_interface if bind_interface is not None else ''
 5589        '''
 5590         Bind interface
 5591        '''
 5592        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5593        '''
 5594
 5595        '''
 5596        self.egress_filter = egress_filter if egress_filter is not None else ''
 5597        '''
 5598         A filter applied to the routing logic to pin datasource to nodes.
 5599        '''
 5600        self.endpoint = endpoint if endpoint is not None else ''
 5601        '''
 5602
 5603        '''
 5604        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5605        '''
 5606         The path used to check the health of your connection.  Defaults to `default`.
 5607        '''
 5608        self.healthy = healthy if healthy is not None else False
 5609        '''
 5610         True if the datasource is reachable and the credentials are valid.
 5611        '''
 5612        self.id = id if id is not None else ''
 5613        '''
 5614         Unique identifier of the Resource.
 5615        '''
 5616        self.name = name if name is not None else ''
 5617        '''
 5618         Unique human-readable name of the Resource.
 5619        '''
 5620        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5621        '''
 5622         ID of the secret store containing credentials for this resource, if any.
 5623        '''
 5624        self.service_account_key = service_account_key if service_account_key is not None else ''
 5625        '''
 5626
 5627        '''
 5628        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5629        '''
 5630         Tags is a map of key, value pairs.
 5631        '''
 5632
 5633    def __repr__(self):
 5634        return '<sdm.GoogleGKEUserImpersonation ' + \
 5635            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5636            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5637            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5638            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5639            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5640            'healthy: ' + repr(self.healthy) + ' ' +\
 5641            'id: ' + repr(self.id) + ' ' +\
 5642            'name: ' + repr(self.name) + ' ' +\
 5643            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5644            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5645            'tags: ' + repr(self.tags) + ' ' +\
 5646            '>'
 5647
 5648    def to_dict(self):
 5649        return {
 5650            'bind_interface': self.bind_interface,
 5651            'certificate_authority': self.certificate_authority,
 5652            'egress_filter': self.egress_filter,
 5653            'endpoint': self.endpoint,
 5654            'healthcheck_namespace': self.healthcheck_namespace,
 5655            'healthy': self.healthy,
 5656            'id': self.id,
 5657            'name': self.name,
 5658            'secret_store_id': self.secret_store_id,
 5659            'service_account_key': self.service_account_key,
 5660            'tags': self.tags,
 5661        }
 5662
 5663    @classmethod
 5664    def from_dict(cls, d):
 5665        return cls(
 5666            bind_interface=d.get('bind_interface'),
 5667            certificate_authority=d.get('certificate_authority'),
 5668            egress_filter=d.get('egress_filter'),
 5669            endpoint=d.get('endpoint'),
 5670            healthcheck_namespace=d.get('healthcheck_namespace'),
 5671            healthy=d.get('healthy'),
 5672            id=d.get('id'),
 5673            name=d.get('name'),
 5674            secret_store_id=d.get('secret_store_id'),
 5675            service_account_key=d.get('service_account_key'),
 5676            tags=d.get('tags'),
 5677        )
 5678
 5679
 5680class Greenplum:
 5681    '''
 5682
 5683    '''
 5684    __slots__ = [
 5685        'bind_interface',
 5686        'database',
 5687        'egress_filter',
 5688        'healthy',
 5689        'hostname',
 5690        'id',
 5691        'name',
 5692        'override_database',
 5693        'password',
 5694        'port',
 5695        'port_override',
 5696        'secret_store_id',
 5697        'tags',
 5698        'username',
 5699    ]
 5700
 5701    def __init__(
 5702        self,
 5703        bind_interface=None,
 5704        database=None,
 5705        egress_filter=None,
 5706        healthy=None,
 5707        hostname=None,
 5708        id=None,
 5709        name=None,
 5710        override_database=None,
 5711        password=None,
 5712        port=None,
 5713        port_override=None,
 5714        secret_store_id=None,
 5715        tags=None,
 5716        username=None,
 5717    ):
 5718        self.bind_interface = bind_interface if bind_interface is not None else ''
 5719        '''
 5720         Bind interface
 5721        '''
 5722        self.database = database if database is not None else ''
 5723        '''
 5724
 5725        '''
 5726        self.egress_filter = egress_filter if egress_filter is not None else ''
 5727        '''
 5728         A filter applied to the routing logic to pin datasource to nodes.
 5729        '''
 5730        self.healthy = healthy if healthy is not None else False
 5731        '''
 5732         True if the datasource is reachable and the credentials are valid.
 5733        '''
 5734        self.hostname = hostname if hostname is not None else ''
 5735        '''
 5736
 5737        '''
 5738        self.id = id if id is not None else ''
 5739        '''
 5740         Unique identifier of the Resource.
 5741        '''
 5742        self.name = name if name is not None else ''
 5743        '''
 5744         Unique human-readable name of the Resource.
 5745        '''
 5746        self.override_database = override_database if override_database is not None else False
 5747        '''
 5748
 5749        '''
 5750        self.password = password if password is not None else ''
 5751        '''
 5752
 5753        '''
 5754        self.port = port if port is not None else 0
 5755        '''
 5756
 5757        '''
 5758        self.port_override = port_override if port_override is not None else 0
 5759        '''
 5760
 5761        '''
 5762        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5763        '''
 5764         ID of the secret store containing credentials for this resource, if any.
 5765        '''
 5766        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5767        '''
 5768         Tags is a map of key, value pairs.
 5769        '''
 5770        self.username = username if username is not None else ''
 5771        '''
 5772
 5773        '''
 5774
 5775    def __repr__(self):
 5776        return '<sdm.Greenplum ' + \
 5777            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5778            'database: ' + repr(self.database) + ' ' +\
 5779            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5780            'healthy: ' + repr(self.healthy) + ' ' +\
 5781            'hostname: ' + repr(self.hostname) + ' ' +\
 5782            'id: ' + repr(self.id) + ' ' +\
 5783            'name: ' + repr(self.name) + ' ' +\
 5784            'override_database: ' + repr(self.override_database) + ' ' +\
 5785            'password: ' + repr(self.password) + ' ' +\
 5786            'port: ' + repr(self.port) + ' ' +\
 5787            'port_override: ' + repr(self.port_override) + ' ' +\
 5788            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5789            'tags: ' + repr(self.tags) + ' ' +\
 5790            'username: ' + repr(self.username) + ' ' +\
 5791            '>'
 5792
 5793    def to_dict(self):
 5794        return {
 5795            'bind_interface': self.bind_interface,
 5796            'database': self.database,
 5797            'egress_filter': self.egress_filter,
 5798            'healthy': self.healthy,
 5799            'hostname': self.hostname,
 5800            'id': self.id,
 5801            'name': self.name,
 5802            'override_database': self.override_database,
 5803            'password': self.password,
 5804            'port': self.port,
 5805            'port_override': self.port_override,
 5806            'secret_store_id': self.secret_store_id,
 5807            'tags': self.tags,
 5808            'username': self.username,
 5809        }
 5810
 5811    @classmethod
 5812    def from_dict(cls, d):
 5813        return cls(
 5814            bind_interface=d.get('bind_interface'),
 5815            database=d.get('database'),
 5816            egress_filter=d.get('egress_filter'),
 5817            healthy=d.get('healthy'),
 5818            hostname=d.get('hostname'),
 5819            id=d.get('id'),
 5820            name=d.get('name'),
 5821            override_database=d.get('override_database'),
 5822            password=d.get('password'),
 5823            port=d.get('port'),
 5824            port_override=d.get('port_override'),
 5825            secret_store_id=d.get('secret_store_id'),
 5826            tags=d.get('tags'),
 5827            username=d.get('username'),
 5828        )
 5829
 5830
 5831class HTTPAuth:
 5832    '''
 5833
 5834    '''
 5835    __slots__ = [
 5836        'auth_header',
 5837        'bind_interface',
 5838        'default_path',
 5839        'egress_filter',
 5840        'headers_blacklist',
 5841        'healthcheck_path',
 5842        'healthy',
 5843        'id',
 5844        'name',
 5845        'secret_store_id',
 5846        'subdomain',
 5847        'tags',
 5848        'url',
 5849    ]
 5850
 5851    def __init__(
 5852        self,
 5853        auth_header=None,
 5854        bind_interface=None,
 5855        default_path=None,
 5856        egress_filter=None,
 5857        headers_blacklist=None,
 5858        healthcheck_path=None,
 5859        healthy=None,
 5860        id=None,
 5861        name=None,
 5862        secret_store_id=None,
 5863        subdomain=None,
 5864        tags=None,
 5865        url=None,
 5866    ):
 5867        self.auth_header = auth_header if auth_header is not None else ''
 5868        '''
 5869
 5870        '''
 5871        self.bind_interface = bind_interface if bind_interface is not None else ''
 5872        '''
 5873         Bind interface
 5874        '''
 5875        self.default_path = default_path if default_path is not None else ''
 5876        '''
 5877
 5878        '''
 5879        self.egress_filter = egress_filter if egress_filter is not None else ''
 5880        '''
 5881         A filter applied to the routing logic to pin datasource to nodes.
 5882        '''
 5883        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5884        '''
 5885
 5886        '''
 5887        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5888        '''
 5889
 5890        '''
 5891        self.healthy = healthy if healthy is not None else False
 5892        '''
 5893         True if the datasource is reachable and the credentials are valid.
 5894        '''
 5895        self.id = id if id is not None else ''
 5896        '''
 5897         Unique identifier of the Resource.
 5898        '''
 5899        self.name = name if name is not None else ''
 5900        '''
 5901         Unique human-readable name of the Resource.
 5902        '''
 5903        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5904        '''
 5905         ID of the secret store containing credentials for this resource, if any.
 5906        '''
 5907        self.subdomain = subdomain if subdomain is not None else ''
 5908        '''
 5909
 5910        '''
 5911        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5912        '''
 5913         Tags is a map of key, value pairs.
 5914        '''
 5915        self.url = url if url is not None else ''
 5916        '''
 5917
 5918        '''
 5919
 5920    def __repr__(self):
 5921        return '<sdm.HTTPAuth ' + \
 5922            'auth_header: ' + repr(self.auth_header) + ' ' +\
 5923            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5924            'default_path: ' + repr(self.default_path) + ' ' +\
 5925            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5926            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5927            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5928            'healthy: ' + repr(self.healthy) + ' ' +\
 5929            'id: ' + repr(self.id) + ' ' +\
 5930            'name: ' + repr(self.name) + ' ' +\
 5931            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5932            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5933            'tags: ' + repr(self.tags) + ' ' +\
 5934            'url: ' + repr(self.url) + ' ' +\
 5935            '>'
 5936
 5937    def to_dict(self):
 5938        return {
 5939            'auth_header': self.auth_header,
 5940            'bind_interface': self.bind_interface,
 5941            'default_path': self.default_path,
 5942            'egress_filter': self.egress_filter,
 5943            'headers_blacklist': self.headers_blacklist,
 5944            'healthcheck_path': self.healthcheck_path,
 5945            'healthy': self.healthy,
 5946            'id': self.id,
 5947            'name': self.name,
 5948            'secret_store_id': self.secret_store_id,
 5949            'subdomain': self.subdomain,
 5950            'tags': self.tags,
 5951            'url': self.url,
 5952        }
 5953
 5954    @classmethod
 5955    def from_dict(cls, d):
 5956        return cls(
 5957            auth_header=d.get('auth_header'),
 5958            bind_interface=d.get('bind_interface'),
 5959            default_path=d.get('default_path'),
 5960            egress_filter=d.get('egress_filter'),
 5961            headers_blacklist=d.get('headers_blacklist'),
 5962            healthcheck_path=d.get('healthcheck_path'),
 5963            healthy=d.get('healthy'),
 5964            id=d.get('id'),
 5965            name=d.get('name'),
 5966            secret_store_id=d.get('secret_store_id'),
 5967            subdomain=d.get('subdomain'),
 5968            tags=d.get('tags'),
 5969            url=d.get('url'),
 5970        )
 5971
 5972
 5973class HTTPBasicAuth:
 5974    '''
 5975
 5976    '''
 5977    __slots__ = [
 5978        'bind_interface',
 5979        'default_path',
 5980        'egress_filter',
 5981        'headers_blacklist',
 5982        'healthcheck_path',
 5983        'healthy',
 5984        'id',
 5985        'name',
 5986        'password',
 5987        'secret_store_id',
 5988        'subdomain',
 5989        'tags',
 5990        'url',
 5991        'username',
 5992    ]
 5993
 5994    def __init__(
 5995        self,
 5996        bind_interface=None,
 5997        default_path=None,
 5998        egress_filter=None,
 5999        headers_blacklist=None,
 6000        healthcheck_path=None,
 6001        healthy=None,
 6002        id=None,
 6003        name=None,
 6004        password=None,
 6005        secret_store_id=None,
 6006        subdomain=None,
 6007        tags=None,
 6008        url=None,
 6009        username=None,
 6010    ):
 6011        self.bind_interface = bind_interface if bind_interface is not None else ''
 6012        '''
 6013         Bind interface
 6014        '''
 6015        self.default_path = default_path if default_path is not None else ''
 6016        '''
 6017
 6018        '''
 6019        self.egress_filter = egress_filter if egress_filter is not None else ''
 6020        '''
 6021         A filter applied to the routing logic to pin datasource to nodes.
 6022        '''
 6023        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 6024        '''
 6025
 6026        '''
 6027        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 6028        '''
 6029
 6030        '''
 6031        self.healthy = healthy if healthy is not None else False
 6032        '''
 6033         True if the datasource is reachable and the credentials are valid.
 6034        '''
 6035        self.id = id if id is not None else ''
 6036        '''
 6037         Unique identifier of the Resource.
 6038        '''
 6039        self.name = name if name is not None else ''
 6040        '''
 6041         Unique human-readable name of the Resource.
 6042        '''
 6043        self.password = password if password is not None else ''
 6044        '''
 6045
 6046        '''
 6047        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6048        '''
 6049         ID of the secret store containing credentials for this resource, if any.
 6050        '''
 6051        self.subdomain = subdomain if subdomain is not None else ''
 6052        '''
 6053
 6054        '''
 6055        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6056        '''
 6057         Tags is a map of key, value pairs.
 6058        '''
 6059        self.url = url if url is not None else ''
 6060        '''
 6061
 6062        '''
 6063        self.username = username if username is not None else ''
 6064        '''
 6065
 6066        '''
 6067
 6068    def __repr__(self):
 6069        return '<sdm.HTTPBasicAuth ' + \
 6070            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6071            'default_path: ' + repr(self.default_path) + ' ' +\
 6072            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6073            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 6074            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 6075            'healthy: ' + repr(self.healthy) + ' ' +\
 6076            'id: ' + repr(self.id) + ' ' +\
 6077            'name: ' + repr(self.name) + ' ' +\
 6078            'password: ' + repr(self.password) + ' ' +\
 6079            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6080            'subdomain: ' + repr(self.subdomain) + ' ' +\
 6081            'tags: ' + repr(self.tags) + ' ' +\
 6082            'url: ' + repr(self.url) + ' ' +\
 6083            'username: ' + repr(self.username) + ' ' +\
 6084            '>'
 6085
 6086    def to_dict(self):
 6087        return {
 6088            'bind_interface': self.bind_interface,
 6089            'default_path': self.default_path,
 6090            'egress_filter': self.egress_filter,
 6091            'headers_blacklist': self.headers_blacklist,
 6092            'healthcheck_path': self.healthcheck_path,
 6093            'healthy': self.healthy,
 6094            'id': self.id,
 6095            'name': self.name,
 6096            'password': self.password,
 6097            'secret_store_id': self.secret_store_id,
 6098            'subdomain': self.subdomain,
 6099            'tags': self.tags,
 6100            'url': self.url,
 6101            'username': self.username,
 6102        }
 6103
 6104    @classmethod
 6105    def from_dict(cls, d):
 6106        return cls(
 6107            bind_interface=d.get('bind_interface'),
 6108            default_path=d.get('default_path'),
 6109            egress_filter=d.get('egress_filter'),
 6110            headers_blacklist=d.get('headers_blacklist'),
 6111            healthcheck_path=d.get('healthcheck_path'),
 6112            healthy=d.get('healthy'),
 6113            id=d.get('id'),
 6114            name=d.get('name'),
 6115            password=d.get('password'),
 6116            secret_store_id=d.get('secret_store_id'),
 6117            subdomain=d.get('subdomain'),
 6118            tags=d.get('tags'),
 6119            url=d.get('url'),
 6120            username=d.get('username'),
 6121        )
 6122
 6123
 6124class HTTPNoAuth:
 6125    '''
 6126
 6127    '''
 6128    __slots__ = [
 6129        'bind_interface',
 6130        'default_path',
 6131        'egress_filter',
 6132        'headers_blacklist',
 6133        'healthcheck_path',
 6134        'healthy',
 6135        'id',
 6136        'name',
 6137        'secret_store_id',
 6138        'subdomain',
 6139        'tags',
 6140        'url',
 6141    ]
 6142
 6143    def __init__(
 6144        self,
 6145        bind_interface=None,
 6146        default_path=None,
 6147        egress_filter=None,
 6148        headers_blacklist=None,
 6149        healthcheck_path=None,
 6150        healthy=None,
 6151        id=None,
 6152        name=None,
 6153        secret_store_id=None,
 6154        subdomain=None,
 6155        tags=None,
 6156        url=None,
 6157    ):
 6158        self.bind_interface = bind_interface if bind_interface is not None else ''
 6159        '''
 6160         Bind interface
 6161        '''
 6162        self.default_path = default_path if default_path is not None else ''
 6163        '''
 6164
 6165        '''
 6166        self.egress_filter = egress_filter if egress_filter is not None else ''
 6167        '''
 6168         A filter applied to the routing logic to pin datasource to nodes.
 6169        '''
 6170        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 6171        '''
 6172
 6173        '''
 6174        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 6175        '''
 6176
 6177        '''
 6178        self.healthy = healthy if healthy is not None else False
 6179        '''
 6180         True if the datasource is reachable and the credentials are valid.
 6181        '''
 6182        self.id = id if id is not None else ''
 6183        '''
 6184         Unique identifier of the Resource.
 6185        '''
 6186        self.name = name if name is not None else ''
 6187        '''
 6188         Unique human-readable name of the Resource.
 6189        '''
 6190        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6191        '''
 6192         ID of the secret store containing credentials for this resource, if any.
 6193        '''
 6194        self.subdomain = subdomain if subdomain is not None else ''
 6195        '''
 6196
 6197        '''
 6198        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6199        '''
 6200         Tags is a map of key, value pairs.
 6201        '''
 6202        self.url = url if url is not None else ''
 6203        '''
 6204
 6205        '''
 6206
 6207    def __repr__(self):
 6208        return '<sdm.HTTPNoAuth ' + \
 6209            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6210            'default_path: ' + repr(self.default_path) + ' ' +\
 6211            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6212            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 6213            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 6214            'healthy: ' + repr(self.healthy) + ' ' +\
 6215            'id: ' + repr(self.id) + ' ' +\
 6216            'name: ' + repr(self.name) + ' ' +\
 6217            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6218            'subdomain: ' + repr(self.subdomain) + ' ' +\
 6219            'tags: ' + repr(self.tags) + ' ' +\
 6220            'url: ' + repr(self.url) + ' ' +\
 6221            '>'
 6222
 6223    def to_dict(self):
 6224        return {
 6225            'bind_interface': self.bind_interface,
 6226            'default_path': self.default_path,
 6227            'egress_filter': self.egress_filter,
 6228            'headers_blacklist': self.headers_blacklist,
 6229            'healthcheck_path': self.healthcheck_path,
 6230            'healthy': self.healthy,
 6231            'id': self.id,
 6232            'name': self.name,
 6233            'secret_store_id': self.secret_store_id,
 6234            'subdomain': self.subdomain,
 6235            'tags': self.tags,
 6236            'url': self.url,
 6237        }
 6238
 6239    @classmethod
 6240    def from_dict(cls, d):
 6241        return cls(
 6242            bind_interface=d.get('bind_interface'),
 6243            default_path=d.get('default_path'),
 6244            egress_filter=d.get('egress_filter'),
 6245            headers_blacklist=d.get('headers_blacklist'),
 6246            healthcheck_path=d.get('healthcheck_path'),
 6247            healthy=d.get('healthy'),
 6248            id=d.get('id'),
 6249            name=d.get('name'),
 6250            secret_store_id=d.get('secret_store_id'),
 6251            subdomain=d.get('subdomain'),
 6252            tags=d.get('tags'),
 6253            url=d.get('url'),
 6254        )
 6255
 6256
 6257class Kubernetes:
 6258    '''
 6259
 6260    '''
 6261    __slots__ = [
 6262        'bind_interface',
 6263        'certificate_authority',
 6264        'client_certificate',
 6265        'client_key',
 6266        'egress_filter',
 6267        'healthcheck_namespace',
 6268        'healthy',
 6269        'hostname',
 6270        'id',
 6271        'name',
 6272        'port',
 6273        'port_override',
 6274        'remote_identity_group_id',
 6275        'remote_identity_healthcheck_username',
 6276        'secret_store_id',
 6277        'tags',
 6278    ]
 6279
 6280    def __init__(
 6281        self,
 6282        bind_interface=None,
 6283        certificate_authority=None,
 6284        client_certificate=None,
 6285        client_key=None,
 6286        egress_filter=None,
 6287        healthcheck_namespace=None,
 6288        healthy=None,
 6289        hostname=None,
 6290        id=None,
 6291        name=None,
 6292        port=None,
 6293        port_override=None,
 6294        remote_identity_group_id=None,
 6295        remote_identity_healthcheck_username=None,
 6296        secret_store_id=None,
 6297        tags=None,
 6298    ):
 6299        self.bind_interface = bind_interface if bind_interface is not None else ''
 6300        '''
 6301         Bind interface
 6302        '''
 6303        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6304        '''
 6305
 6306        '''
 6307        self.client_certificate = client_certificate if client_certificate is not None else ''
 6308        '''
 6309
 6310        '''
 6311        self.client_key = client_key if client_key is not None else ''
 6312        '''
 6313
 6314        '''
 6315        self.egress_filter = egress_filter if egress_filter is not None else ''
 6316        '''
 6317         A filter applied to the routing logic to pin datasource to nodes.
 6318        '''
 6319        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6320        '''
 6321         The path used to check the health of your connection.  Defaults to `default`.
 6322        '''
 6323        self.healthy = healthy if healthy is not None else False
 6324        '''
 6325         True if the datasource is reachable and the credentials are valid.
 6326        '''
 6327        self.hostname = hostname if hostname is not None else ''
 6328        '''
 6329
 6330        '''
 6331        self.id = id if id is not None else ''
 6332        '''
 6333         Unique identifier of the Resource.
 6334        '''
 6335        self.name = name if name is not None else ''
 6336        '''
 6337         Unique human-readable name of the Resource.
 6338        '''
 6339        self.port = port if port is not None else 0
 6340        '''
 6341
 6342        '''
 6343        self.port_override = port_override if port_override is not None else 0
 6344        '''
 6345
 6346        '''
 6347        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6348        '''
 6349
 6350        '''
 6351        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6352        '''
 6353
 6354        '''
 6355        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6356        '''
 6357         ID of the secret store containing credentials for this resource, if any.
 6358        '''
 6359        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6360        '''
 6361         Tags is a map of key, value pairs.
 6362        '''
 6363
 6364    def __repr__(self):
 6365        return '<sdm.Kubernetes ' + \
 6366            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6367            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6368            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6369            'client_key: ' + repr(self.client_key) + ' ' +\
 6370            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6371            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6372            'healthy: ' + repr(self.healthy) + ' ' +\
 6373            'hostname: ' + repr(self.hostname) + ' ' +\
 6374            'id: ' + repr(self.id) + ' ' +\
 6375            'name: ' + repr(self.name) + ' ' +\
 6376            'port: ' + repr(self.port) + ' ' +\
 6377            'port_override: ' + repr(self.port_override) + ' ' +\
 6378            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6379            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6380            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6381            'tags: ' + repr(self.tags) + ' ' +\
 6382            '>'
 6383
 6384    def to_dict(self):
 6385        return {
 6386            'bind_interface': self.bind_interface,
 6387            'certificate_authority': self.certificate_authority,
 6388            'client_certificate': self.client_certificate,
 6389            'client_key': self.client_key,
 6390            'egress_filter': self.egress_filter,
 6391            'healthcheck_namespace': self.healthcheck_namespace,
 6392            'healthy': self.healthy,
 6393            'hostname': self.hostname,
 6394            'id': self.id,
 6395            'name': self.name,
 6396            'port': self.port,
 6397            'port_override': self.port_override,
 6398            'remote_identity_group_id': self.remote_identity_group_id,
 6399            'remote_identity_healthcheck_username':
 6400            self.remote_identity_healthcheck_username,
 6401            'secret_store_id': self.secret_store_id,
 6402            'tags': self.tags,
 6403        }
 6404
 6405    @classmethod
 6406    def from_dict(cls, d):
 6407        return cls(
 6408            bind_interface=d.get('bind_interface'),
 6409            certificate_authority=d.get('certificate_authority'),
 6410            client_certificate=d.get('client_certificate'),
 6411            client_key=d.get('client_key'),
 6412            egress_filter=d.get('egress_filter'),
 6413            healthcheck_namespace=d.get('healthcheck_namespace'),
 6414            healthy=d.get('healthy'),
 6415            hostname=d.get('hostname'),
 6416            id=d.get('id'),
 6417            name=d.get('name'),
 6418            port=d.get('port'),
 6419            port_override=d.get('port_override'),
 6420            remote_identity_group_id=d.get('remote_identity_group_id'),
 6421            remote_identity_healthcheck_username=d.get(
 6422                'remote_identity_healthcheck_username'),
 6423            secret_store_id=d.get('secret_store_id'),
 6424            tags=d.get('tags'),
 6425        )
 6426
 6427
 6428class KubernetesBasicAuth:
 6429    '''
 6430
 6431    '''
 6432    __slots__ = [
 6433        'bind_interface',
 6434        'egress_filter',
 6435        'healthcheck_namespace',
 6436        'healthy',
 6437        'hostname',
 6438        'id',
 6439        'name',
 6440        'password',
 6441        'port',
 6442        'port_override',
 6443        'secret_store_id',
 6444        'tags',
 6445        'username',
 6446    ]
 6447
 6448    def __init__(
 6449        self,
 6450        bind_interface=None,
 6451        egress_filter=None,
 6452        healthcheck_namespace=None,
 6453        healthy=None,
 6454        hostname=None,
 6455        id=None,
 6456        name=None,
 6457        password=None,
 6458        port=None,
 6459        port_override=None,
 6460        secret_store_id=None,
 6461        tags=None,
 6462        username=None,
 6463    ):
 6464        self.bind_interface = bind_interface if bind_interface is not None else ''
 6465        '''
 6466         Bind interface
 6467        '''
 6468        self.egress_filter = egress_filter if egress_filter is not None else ''
 6469        '''
 6470         A filter applied to the routing logic to pin datasource to nodes.
 6471        '''
 6472        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6473        '''
 6474         The path used to check the health of your connection.  Defaults to `default`.
 6475        '''
 6476        self.healthy = healthy if healthy is not None else False
 6477        '''
 6478         True if the datasource is reachable and the credentials are valid.
 6479        '''
 6480        self.hostname = hostname if hostname is not None else ''
 6481        '''
 6482
 6483        '''
 6484        self.id = id if id is not None else ''
 6485        '''
 6486         Unique identifier of the Resource.
 6487        '''
 6488        self.name = name if name is not None else ''
 6489        '''
 6490         Unique human-readable name of the Resource.
 6491        '''
 6492        self.password = password if password is not None else ''
 6493        '''
 6494
 6495        '''
 6496        self.port = port if port is not None else 0
 6497        '''
 6498
 6499        '''
 6500        self.port_override = port_override if port_override is not None else 0
 6501        '''
 6502
 6503        '''
 6504        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6505        '''
 6506         ID of the secret store containing credentials for this resource, if any.
 6507        '''
 6508        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6509        '''
 6510         Tags is a map of key, value pairs.
 6511        '''
 6512        self.username = username if username is not None else ''
 6513        '''
 6514
 6515        '''
 6516
 6517    def __repr__(self):
 6518        return '<sdm.KubernetesBasicAuth ' + \
 6519            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6520            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6521            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6522            'healthy: ' + repr(self.healthy) + ' ' +\
 6523            'hostname: ' + repr(self.hostname) + ' ' +\
 6524            'id: ' + repr(self.id) + ' ' +\
 6525            'name: ' + repr(self.name) + ' ' +\
 6526            'password: ' + repr(self.password) + ' ' +\
 6527            'port: ' + repr(self.port) + ' ' +\
 6528            'port_override: ' + repr(self.port_override) + ' ' +\
 6529            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6530            'tags: ' + repr(self.tags) + ' ' +\
 6531            'username: ' + repr(self.username) + ' ' +\
 6532            '>'
 6533
 6534    def to_dict(self):
 6535        return {
 6536            'bind_interface': self.bind_interface,
 6537            'egress_filter': self.egress_filter,
 6538            'healthcheck_namespace': self.healthcheck_namespace,
 6539            'healthy': self.healthy,
 6540            'hostname': self.hostname,
 6541            'id': self.id,
 6542            'name': self.name,
 6543            'password': self.password,
 6544            'port': self.port,
 6545            'port_override': self.port_override,
 6546            'secret_store_id': self.secret_store_id,
 6547            'tags': self.tags,
 6548            'username': self.username,
 6549        }
 6550
 6551    @classmethod
 6552    def from_dict(cls, d):
 6553        return cls(
 6554            bind_interface=d.get('bind_interface'),
 6555            egress_filter=d.get('egress_filter'),
 6556            healthcheck_namespace=d.get('healthcheck_namespace'),
 6557            healthy=d.get('healthy'),
 6558            hostname=d.get('hostname'),
 6559            id=d.get('id'),
 6560            name=d.get('name'),
 6561            password=d.get('password'),
 6562            port=d.get('port'),
 6563            port_override=d.get('port_override'),
 6564            secret_store_id=d.get('secret_store_id'),
 6565            tags=d.get('tags'),
 6566            username=d.get('username'),
 6567        )
 6568
 6569
 6570class KubernetesServiceAccount:
 6571    '''
 6572
 6573    '''
 6574    __slots__ = [
 6575        'bind_interface',
 6576        'egress_filter',
 6577        'healthcheck_namespace',
 6578        'healthy',
 6579        'hostname',
 6580        'id',
 6581        'name',
 6582        'port',
 6583        'port_override',
 6584        'remote_identity_group_id',
 6585        'remote_identity_healthcheck_username',
 6586        'secret_store_id',
 6587        'tags',
 6588        'token',
 6589    ]
 6590
 6591    def __init__(
 6592        self,
 6593        bind_interface=None,
 6594        egress_filter=None,
 6595        healthcheck_namespace=None,
 6596        healthy=None,
 6597        hostname=None,
 6598        id=None,
 6599        name=None,
 6600        port=None,
 6601        port_override=None,
 6602        remote_identity_group_id=None,
 6603        remote_identity_healthcheck_username=None,
 6604        secret_store_id=None,
 6605        tags=None,
 6606        token=None,
 6607    ):
 6608        self.bind_interface = bind_interface if bind_interface is not None else ''
 6609        '''
 6610         Bind interface
 6611        '''
 6612        self.egress_filter = egress_filter if egress_filter is not None else ''
 6613        '''
 6614         A filter applied to the routing logic to pin datasource to nodes.
 6615        '''
 6616        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6617        '''
 6618         The path used to check the health of your connection.  Defaults to `default`.
 6619        '''
 6620        self.healthy = healthy if healthy is not None else False
 6621        '''
 6622         True if the datasource is reachable and the credentials are valid.
 6623        '''
 6624        self.hostname = hostname if hostname is not None else ''
 6625        '''
 6626
 6627        '''
 6628        self.id = id if id is not None else ''
 6629        '''
 6630         Unique identifier of the Resource.
 6631        '''
 6632        self.name = name if name is not None else ''
 6633        '''
 6634         Unique human-readable name of the Resource.
 6635        '''
 6636        self.port = port if port is not None else 0
 6637        '''
 6638
 6639        '''
 6640        self.port_override = port_override if port_override is not None else 0
 6641        '''
 6642
 6643        '''
 6644        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6645        '''
 6646
 6647        '''
 6648        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6649        '''
 6650
 6651        '''
 6652        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6653        '''
 6654         ID of the secret store containing credentials for this resource, if any.
 6655        '''
 6656        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6657        '''
 6658         Tags is a map of key, value pairs.
 6659        '''
 6660        self.token = token if token is not None else ''
 6661        '''
 6662
 6663        '''
 6664
 6665    def __repr__(self):
 6666        return '<sdm.KubernetesServiceAccount ' + \
 6667            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6668            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6669            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6670            'healthy: ' + repr(self.healthy) + ' ' +\
 6671            'hostname: ' + repr(self.hostname) + ' ' +\
 6672            'id: ' + repr(self.id) + ' ' +\
 6673            'name: ' + repr(self.name) + ' ' +\
 6674            'port: ' + repr(self.port) + ' ' +\
 6675            'port_override: ' + repr(self.port_override) + ' ' +\
 6676            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6677            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6678            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6679            'tags: ' + repr(self.tags) + ' ' +\
 6680            'token: ' + repr(self.token) + ' ' +\
 6681            '>'
 6682
 6683    def to_dict(self):
 6684        return {
 6685            'bind_interface': self.bind_interface,
 6686            'egress_filter': self.egress_filter,
 6687            'healthcheck_namespace': self.healthcheck_namespace,
 6688            'healthy': self.healthy,
 6689            'hostname': self.hostname,
 6690            'id': self.id,
 6691            'name': self.name,
 6692            'port': self.port,
 6693            'port_override': self.port_override,
 6694            'remote_identity_group_id': self.remote_identity_group_id,
 6695            'remote_identity_healthcheck_username':
 6696            self.remote_identity_healthcheck_username,
 6697            'secret_store_id': self.secret_store_id,
 6698            'tags': self.tags,
 6699            'token': self.token,
 6700        }
 6701
 6702    @classmethod
 6703    def from_dict(cls, d):
 6704        return cls(
 6705            bind_interface=d.get('bind_interface'),
 6706            egress_filter=d.get('egress_filter'),
 6707            healthcheck_namespace=d.get('healthcheck_namespace'),
 6708            healthy=d.get('healthy'),
 6709            hostname=d.get('hostname'),
 6710            id=d.get('id'),
 6711            name=d.get('name'),
 6712            port=d.get('port'),
 6713            port_override=d.get('port_override'),
 6714            remote_identity_group_id=d.get('remote_identity_group_id'),
 6715            remote_identity_healthcheck_username=d.get(
 6716                'remote_identity_healthcheck_username'),
 6717            secret_store_id=d.get('secret_store_id'),
 6718            tags=d.get('tags'),
 6719            token=d.get('token'),
 6720        )
 6721
 6722
 6723class KubernetesServiceAccountUserImpersonation:
 6724    '''
 6725
 6726    '''
 6727    __slots__ = [
 6728        'bind_interface',
 6729        'egress_filter',
 6730        'healthcheck_namespace',
 6731        'healthy',
 6732        'hostname',
 6733        'id',
 6734        'name',
 6735        'port',
 6736        'port_override',
 6737        'secret_store_id',
 6738        'tags',
 6739        'token',
 6740    ]
 6741
 6742    def __init__(
 6743        self,
 6744        bind_interface=None,
 6745        egress_filter=None,
 6746        healthcheck_namespace=None,
 6747        healthy=None,
 6748        hostname=None,
 6749        id=None,
 6750        name=None,
 6751        port=None,
 6752        port_override=None,
 6753        secret_store_id=None,
 6754        tags=None,
 6755        token=None,
 6756    ):
 6757        self.bind_interface = bind_interface if bind_interface is not None else ''
 6758        '''
 6759         Bind interface
 6760        '''
 6761        self.egress_filter = egress_filter if egress_filter is not None else ''
 6762        '''
 6763         A filter applied to the routing logic to pin datasource to nodes.
 6764        '''
 6765        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6766        '''
 6767         The path used to check the health of your connection.  Defaults to `default`.
 6768        '''
 6769        self.healthy = healthy if healthy is not None else False
 6770        '''
 6771         True if the datasource is reachable and the credentials are valid.
 6772        '''
 6773        self.hostname = hostname if hostname is not None else ''
 6774        '''
 6775
 6776        '''
 6777        self.id = id if id is not None else ''
 6778        '''
 6779         Unique identifier of the Resource.
 6780        '''
 6781        self.name = name if name is not None else ''
 6782        '''
 6783         Unique human-readable name of the Resource.
 6784        '''
 6785        self.port = port if port is not None else 0
 6786        '''
 6787
 6788        '''
 6789        self.port_override = port_override if port_override is not None else 0
 6790        '''
 6791
 6792        '''
 6793        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6794        '''
 6795         ID of the secret store containing credentials for this resource, if any.
 6796        '''
 6797        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6798        '''
 6799         Tags is a map of key, value pairs.
 6800        '''
 6801        self.token = token if token is not None else ''
 6802        '''
 6803
 6804        '''
 6805
 6806    def __repr__(self):
 6807        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
 6808            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6809            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6810            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6811            'healthy: ' + repr(self.healthy) + ' ' +\
 6812            'hostname: ' + repr(self.hostname) + ' ' +\
 6813            'id: ' + repr(self.id) + ' ' +\
 6814            'name: ' + repr(self.name) + ' ' +\
 6815            'port: ' + repr(self.port) + ' ' +\
 6816            'port_override: ' + repr(self.port_override) + ' ' +\
 6817            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6818            'tags: ' + repr(self.tags) + ' ' +\
 6819            'token: ' + repr(self.token) + ' ' +\
 6820            '>'
 6821
 6822    def to_dict(self):
 6823        return {
 6824            'bind_interface': self.bind_interface,
 6825            'egress_filter': self.egress_filter,
 6826            'healthcheck_namespace': self.healthcheck_namespace,
 6827            'healthy': self.healthy,
 6828            'hostname': self.hostname,
 6829            'id': self.id,
 6830            'name': self.name,
 6831            'port': self.port,
 6832            'port_override': self.port_override,
 6833            'secret_store_id': self.secret_store_id,
 6834            'tags': self.tags,
 6835            'token': self.token,
 6836        }
 6837
 6838    @classmethod
 6839    def from_dict(cls, d):
 6840        return cls(
 6841            bind_interface=d.get('bind_interface'),
 6842            egress_filter=d.get('egress_filter'),
 6843            healthcheck_namespace=d.get('healthcheck_namespace'),
 6844            healthy=d.get('healthy'),
 6845            hostname=d.get('hostname'),
 6846            id=d.get('id'),
 6847            name=d.get('name'),
 6848            port=d.get('port'),
 6849            port_override=d.get('port_override'),
 6850            secret_store_id=d.get('secret_store_id'),
 6851            tags=d.get('tags'),
 6852            token=d.get('token'),
 6853        )
 6854
 6855
 6856class KubernetesUserImpersonation:
 6857    '''
 6858
 6859    '''
 6860    __slots__ = [
 6861        'bind_interface',
 6862        'certificate_authority',
 6863        'client_certificate',
 6864        'client_key',
 6865        'egress_filter',
 6866        'healthcheck_namespace',
 6867        'healthy',
 6868        'hostname',
 6869        'id',
 6870        'name',
 6871        'port',
 6872        'port_override',
 6873        'secret_store_id',
 6874        'tags',
 6875    ]
 6876
 6877    def __init__(
 6878        self,
 6879        bind_interface=None,
 6880        certificate_authority=None,
 6881        client_certificate=None,
 6882        client_key=None,
 6883        egress_filter=None,
 6884        healthcheck_namespace=None,
 6885        healthy=None,
 6886        hostname=None,
 6887        id=None,
 6888        name=None,
 6889        port=None,
 6890        port_override=None,
 6891        secret_store_id=None,
 6892        tags=None,
 6893    ):
 6894        self.bind_interface = bind_interface if bind_interface is not None else ''
 6895        '''
 6896         Bind interface
 6897        '''
 6898        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6899        '''
 6900
 6901        '''
 6902        self.client_certificate = client_certificate if client_certificate is not None else ''
 6903        '''
 6904
 6905        '''
 6906        self.client_key = client_key if client_key is not None else ''
 6907        '''
 6908
 6909        '''
 6910        self.egress_filter = egress_filter if egress_filter is not None else ''
 6911        '''
 6912         A filter applied to the routing logic to pin datasource to nodes.
 6913        '''
 6914        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6915        '''
 6916         The path used to check the health of your connection.  Defaults to `default`.
 6917        '''
 6918        self.healthy = healthy if healthy is not None else False
 6919        '''
 6920         True if the datasource is reachable and the credentials are valid.
 6921        '''
 6922        self.hostname = hostname if hostname is not None else ''
 6923        '''
 6924
 6925        '''
 6926        self.id = id if id is not None else ''
 6927        '''
 6928         Unique identifier of the Resource.
 6929        '''
 6930        self.name = name if name is not None else ''
 6931        '''
 6932         Unique human-readable name of the Resource.
 6933        '''
 6934        self.port = port if port is not None else 0
 6935        '''
 6936
 6937        '''
 6938        self.port_override = port_override if port_override is not None else 0
 6939        '''
 6940
 6941        '''
 6942        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6943        '''
 6944         ID of the secret store containing credentials for this resource, if any.
 6945        '''
 6946        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6947        '''
 6948         Tags is a map of key, value pairs.
 6949        '''
 6950
 6951    def __repr__(self):
 6952        return '<sdm.KubernetesUserImpersonation ' + \
 6953            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6954            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6955            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6956            'client_key: ' + repr(self.client_key) + ' ' +\
 6957            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6958            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6959            'healthy: ' + repr(self.healthy) + ' ' +\
 6960            'hostname: ' + repr(self.hostname) + ' ' +\
 6961            'id: ' + repr(self.id) + ' ' +\
 6962            'name: ' + repr(self.name) + ' ' +\
 6963            'port: ' + repr(self.port) + ' ' +\
 6964            'port_override: ' + repr(self.port_override) + ' ' +\
 6965            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6966            'tags: ' + repr(self.tags) + ' ' +\
 6967            '>'
 6968
 6969    def to_dict(self):
 6970        return {
 6971            'bind_interface': self.bind_interface,
 6972            'certificate_authority': self.certificate_authority,
 6973            'client_certificate': self.client_certificate,
 6974            'client_key': self.client_key,
 6975            'egress_filter': self.egress_filter,
 6976            'healthcheck_namespace': self.healthcheck_namespace,
 6977            'healthy': self.healthy,
 6978            'hostname': self.hostname,
 6979            'id': self.id,
 6980            'name': self.name,
 6981            'port': self.port,
 6982            'port_override': self.port_override,
 6983            'secret_store_id': self.secret_store_id,
 6984            'tags': self.tags,
 6985        }
 6986
 6987    @classmethod
 6988    def from_dict(cls, d):
 6989        return cls(
 6990            bind_interface=d.get('bind_interface'),
 6991            certificate_authority=d.get('certificate_authority'),
 6992            client_certificate=d.get('client_certificate'),
 6993            client_key=d.get('client_key'),
 6994            egress_filter=d.get('egress_filter'),
 6995            healthcheck_namespace=d.get('healthcheck_namespace'),
 6996            healthy=d.get('healthy'),
 6997            hostname=d.get('hostname'),
 6998            id=d.get('id'),
 6999            name=d.get('name'),
 7000            port=d.get('port'),
 7001            port_override=d.get('port_override'),
 7002            secret_store_id=d.get('secret_store_id'),
 7003            tags=d.get('tags'),
 7004        )
 7005
 7006
 7007class MTLSMysql:
 7008    '''
 7009
 7010    '''
 7011    __slots__ = [
 7012        'bind_interface',
 7013        'certificate_authority',
 7014        'client_certificate',
 7015        'client_key',
 7016        'database',
 7017        'egress_filter',
 7018        'healthy',
 7019        'hostname',
 7020        'id',
 7021        'name',
 7022        'password',
 7023        'port',
 7024        'port_override',
 7025        'secret_store_id',
 7026        'server_name',
 7027        'tags',
 7028        'username',
 7029    ]
 7030
 7031    def __init__(
 7032        self,
 7033        bind_interface=None,
 7034        certificate_authority=None,
 7035        client_certificate=None,
 7036        client_key=None,
 7037        database=None,
 7038        egress_filter=None,
 7039        healthy=None,
 7040        hostname=None,
 7041        id=None,
 7042        name=None,
 7043        password=None,
 7044        port=None,
 7045        port_override=None,
 7046        secret_store_id=None,
 7047        server_name=None,
 7048        tags=None,
 7049        username=None,
 7050    ):
 7051        self.bind_interface = bind_interface if bind_interface is not None else ''
 7052        '''
 7053         Bind interface
 7054        '''
 7055        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 7056        '''
 7057
 7058        '''
 7059        self.client_certificate = client_certificate if client_certificate is not None else ''
 7060        '''
 7061
 7062        '''
 7063        self.client_key = client_key if client_key is not None else ''
 7064        '''
 7065
 7066        '''
 7067        self.database = database if database is not None else ''
 7068        '''
 7069
 7070        '''
 7071        self.egress_filter = egress_filter if egress_filter is not None else ''
 7072        '''
 7073         A filter applied to the routing logic to pin datasource to nodes.
 7074        '''
 7075        self.healthy = healthy if healthy is not None else False
 7076        '''
 7077         True if the datasource is reachable and the credentials are valid.
 7078        '''
 7079        self.hostname = hostname if hostname is not None else ''
 7080        '''
 7081
 7082        '''
 7083        self.id = id if id is not None else ''
 7084        '''
 7085         Unique identifier of the Resource.
 7086        '''
 7087        self.name = name if name is not None else ''
 7088        '''
 7089         Unique human-readable name of the Resource.
 7090        '''
 7091        self.password = password if password is not None else ''
 7092        '''
 7093
 7094        '''
 7095        self.port = port if port is not None else 0
 7096        '''
 7097
 7098        '''
 7099        self.port_override = port_override if port_override is not None else 0
 7100        '''
 7101
 7102        '''
 7103        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7104        '''
 7105         ID of the secret store containing credentials for this resource, if any.
 7106        '''
 7107        self.server_name = server_name if server_name is not None else ''
 7108        '''
 7109
 7110        '''
 7111        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7112        '''
 7113         Tags is a map of key, value pairs.
 7114        '''
 7115        self.username = username if username is not None else ''
 7116        '''
 7117
 7118        '''
 7119
 7120    def __repr__(self):
 7121        return '<sdm.MTLSMysql ' + \
 7122            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7123            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 7124            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 7125            'client_key: ' + repr(self.client_key) + ' ' +\
 7126            'database: ' + repr(self.database) + ' ' +\
 7127            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7128            'healthy: ' + repr(self.healthy) + ' ' +\
 7129            'hostname: ' + repr(self.hostname) + ' ' +\
 7130            'id: ' + repr(self.id) + ' ' +\
 7131            'name: ' + repr(self.name) + ' ' +\
 7132            'password: ' + repr(self.password) + ' ' +\
 7133            'port: ' + repr(self.port) + ' ' +\
 7134            'port_override: ' + repr(self.port_override) + ' ' +\
 7135            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7136            'server_name: ' + repr(self.server_name) + ' ' +\
 7137            'tags: ' + repr(self.tags) + ' ' +\
 7138            'username: ' + repr(self.username) + ' ' +\
 7139            '>'
 7140
 7141    def to_dict(self):
 7142        return {
 7143            'bind_interface': self.bind_interface,
 7144            'certificate_authority': self.certificate_authority,
 7145            'client_certificate': self.client_certificate,
 7146            'client_key': self.client_key,
 7147            'database': self.database,
 7148            'egress_filter': self.egress_filter,
 7149            'healthy': self.healthy,
 7150            'hostname': self.hostname,
 7151            'id': self.id,
 7152            'name': self.name,
 7153            'password': self.password,
 7154            'port': self.port,
 7155            'port_override': self.port_override,
 7156            'secret_store_id': self.secret_store_id,
 7157            'server_name': self.server_name,
 7158            'tags': self.tags,
 7159            'username': self.username,
 7160        }
 7161
 7162    @classmethod
 7163    def from_dict(cls, d):
 7164        return cls(
 7165            bind_interface=d.get('bind_interface'),
 7166            certificate_authority=d.get('certificate_authority'),
 7167            client_certificate=d.get('client_certificate'),
 7168            client_key=d.get('client_key'),
 7169            database=d.get('database'),
 7170            egress_filter=d.get('egress_filter'),
 7171            healthy=d.get('healthy'),
 7172            hostname=d.get('hostname'),
 7173            id=d.get('id'),
 7174            name=d.get('name'),
 7175            password=d.get('password'),
 7176            port=d.get('port'),
 7177            port_override=d.get('port_override'),
 7178            secret_store_id=d.get('secret_store_id'),
 7179            server_name=d.get('server_name'),
 7180            tags=d.get('tags'),
 7181            username=d.get('username'),
 7182        )
 7183
 7184
 7185class MTLSPostgres:
 7186    '''
 7187
 7188    '''
 7189    __slots__ = [
 7190        'bind_interface',
 7191        'certificate_authority',
 7192        'client_certificate',
 7193        'client_key',
 7194        'database',
 7195        'egress_filter',
 7196        'healthy',
 7197        'hostname',
 7198        'id',
 7199        'name',
 7200        'override_database',
 7201        'password',
 7202        'port',
 7203        'port_override',
 7204        'secret_store_id',
 7205        'server_name',
 7206        'tags',
 7207        'username',
 7208    ]
 7209
 7210    def __init__(
 7211        self,
 7212        bind_interface=None,
 7213        certificate_authority=None,
 7214        client_certificate=None,
 7215        client_key=None,
 7216        database=None,
 7217        egress_filter=None,
 7218        healthy=None,
 7219        hostname=None,
 7220        id=None,
 7221        name=None,
 7222        override_database=None,
 7223        password=None,
 7224        port=None,
 7225        port_override=None,
 7226        secret_store_id=None,
 7227        server_name=None,
 7228        tags=None,
 7229        username=None,
 7230    ):
 7231        self.bind_interface = bind_interface if bind_interface is not None else ''
 7232        '''
 7233         Bind interface
 7234        '''
 7235        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 7236        '''
 7237
 7238        '''
 7239        self.client_certificate = client_certificate if client_certificate is not None else ''
 7240        '''
 7241
 7242        '''
 7243        self.client_key = client_key if client_key is not None else ''
 7244        '''
 7245
 7246        '''
 7247        self.database = database if database is not None else ''
 7248        '''
 7249
 7250        '''
 7251        self.egress_filter = egress_filter if egress_filter is not None else ''
 7252        '''
 7253         A filter applied to the routing logic to pin datasource to nodes.
 7254        '''
 7255        self.healthy = healthy if healthy is not None else False
 7256        '''
 7257         True if the datasource is reachable and the credentials are valid.
 7258        '''
 7259        self.hostname = hostname if hostname is not None else ''
 7260        '''
 7261
 7262        '''
 7263        self.id = id if id is not None else ''
 7264        '''
 7265         Unique identifier of the Resource.
 7266        '''
 7267        self.name = name if name is not None else ''
 7268        '''
 7269         Unique human-readable name of the Resource.
 7270        '''
 7271        self.override_database = override_database if override_database is not None else False
 7272        '''
 7273
 7274        '''
 7275        self.password = password if password is not None else ''
 7276        '''
 7277
 7278        '''
 7279        self.port = port if port is not None else 0
 7280        '''
 7281
 7282        '''
 7283        self.port_override = port_override if port_override is not None else 0
 7284        '''
 7285
 7286        '''
 7287        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7288        '''
 7289         ID of the secret store containing credentials for this resource, if any.
 7290        '''
 7291        self.server_name = server_name if server_name is not None else ''
 7292        '''
 7293
 7294        '''
 7295        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7296        '''
 7297         Tags is a map of key, value pairs.
 7298        '''
 7299        self.username = username if username is not None else ''
 7300        '''
 7301
 7302        '''
 7303
 7304    def __repr__(self):
 7305        return '<sdm.MTLSPostgres ' + \
 7306            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7307            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 7308            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 7309            'client_key: ' + repr(self.client_key) + ' ' +\
 7310            'database: ' + repr(self.database) + ' ' +\
 7311            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7312            'healthy: ' + repr(self.healthy) + ' ' +\
 7313            'hostname: ' + repr(self.hostname) + ' ' +\
 7314            'id: ' + repr(self.id) + ' ' +\
 7315            'name: ' + repr(self.name) + ' ' +\
 7316            'override_database: ' + repr(self.override_database) + ' ' +\
 7317            'password: ' + repr(self.password) + ' ' +\
 7318            'port: ' + repr(self.port) + ' ' +\
 7319            'port_override: ' + repr(self.port_override) + ' ' +\
 7320            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7321            'server_name: ' + repr(self.server_name) + ' ' +\
 7322            'tags: ' + repr(self.tags) + ' ' +\
 7323            'username: ' + repr(self.username) + ' ' +\
 7324            '>'
 7325
 7326    def to_dict(self):
 7327        return {
 7328            'bind_interface': self.bind_interface,
 7329            'certificate_authority': self.certificate_authority,
 7330            'client_certificate': self.client_certificate,
 7331            'client_key': self.client_key,
 7332            'database': self.database,
 7333            'egress_filter': self.egress_filter,
 7334            'healthy': self.healthy,
 7335            'hostname': self.hostname,
 7336            'id': self.id,
 7337            'name': self.name,
 7338            'override_database': self.override_database,
 7339            'password': self.password,
 7340            'port': self.port,
 7341            'port_override': self.port_override,
 7342            'secret_store_id': self.secret_store_id,
 7343            'server_name': self.server_name,
 7344            'tags': self.tags,
 7345            'username': self.username,
 7346        }
 7347
 7348    @classmethod
 7349    def from_dict(cls, d):
 7350        return cls(
 7351            bind_interface=d.get('bind_interface'),
 7352            certificate_authority=d.get('certificate_authority'),
 7353            client_certificate=d.get('client_certificate'),
 7354            client_key=d.get('client_key'),
 7355            database=d.get('database'),
 7356            egress_filter=d.get('egress_filter'),
 7357            healthy=d.get('healthy'),
 7358            hostname=d.get('hostname'),
 7359            id=d.get('id'),
 7360            name=d.get('name'),
 7361            override_database=d.get('override_database'),
 7362            password=d.get('password'),
 7363            port=d.get('port'),
 7364            port_override=d.get('port_override'),
 7365            secret_store_id=d.get('secret_store_id'),
 7366            server_name=d.get('server_name'),
 7367            tags=d.get('tags'),
 7368            username=d.get('username'),
 7369        )
 7370
 7371
 7372class Maria:
 7373    '''
 7374
 7375    '''
 7376    __slots__ = [
 7377        'bind_interface',
 7378        'database',
 7379        'egress_filter',
 7380        'healthy',
 7381        'hostname',
 7382        'id',
 7383        'name',
 7384        'password',
 7385        'port',
 7386        'port_override',
 7387        'secret_store_id',
 7388        'tags',
 7389        'username',
 7390    ]
 7391
 7392    def __init__(
 7393        self,
 7394        bind_interface=None,
 7395        database=None,
 7396        egress_filter=None,
 7397        healthy=None,
 7398        hostname=None,
 7399        id=None,
 7400        name=None,
 7401        password=None,
 7402        port=None,
 7403        port_override=None,
 7404        secret_store_id=None,
 7405        tags=None,
 7406        username=None,
 7407    ):
 7408        self.bind_interface = bind_interface if bind_interface is not None else ''
 7409        '''
 7410         Bind interface
 7411        '''
 7412        self.database = database if database is not None else ''
 7413        '''
 7414
 7415        '''
 7416        self.egress_filter = egress_filter if egress_filter is not None else ''
 7417        '''
 7418         A filter applied to the routing logic to pin datasource to nodes.
 7419        '''
 7420        self.healthy = healthy if healthy is not None else False
 7421        '''
 7422         True if the datasource is reachable and the credentials are valid.
 7423        '''
 7424        self.hostname = hostname if hostname is not None else ''
 7425        '''
 7426
 7427        '''
 7428        self.id = id if id is not None else ''
 7429        '''
 7430         Unique identifier of the Resource.
 7431        '''
 7432        self.name = name if name is not None else ''
 7433        '''
 7434         Unique human-readable name of the Resource.
 7435        '''
 7436        self.password = password if password is not None else ''
 7437        '''
 7438
 7439        '''
 7440        self.port = port if port is not None else 0
 7441        '''
 7442
 7443        '''
 7444        self.port_override = port_override if port_override is not None else 0
 7445        '''
 7446
 7447        '''
 7448        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7449        '''
 7450         ID of the secret store containing credentials for this resource, if any.
 7451        '''
 7452        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7453        '''
 7454         Tags is a map of key, value pairs.
 7455        '''
 7456        self.username = username if username is not None else ''
 7457        '''
 7458
 7459        '''
 7460
 7461    def __repr__(self):
 7462        return '<sdm.Maria ' + \
 7463            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7464            'database: ' + repr(self.database) + ' ' +\
 7465            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7466            'healthy: ' + repr(self.healthy) + ' ' +\
 7467            'hostname: ' + repr(self.hostname) + ' ' +\
 7468            'id: ' + repr(self.id) + ' ' +\
 7469            'name: ' + repr(self.name) + ' ' +\
 7470            'password: ' + repr(self.password) + ' ' +\
 7471            'port: ' + repr(self.port) + ' ' +\
 7472            'port_override: ' + repr(self.port_override) + ' ' +\
 7473            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7474            'tags: ' + repr(self.tags) + ' ' +\
 7475            'username: ' + repr(self.username) + ' ' +\
 7476            '>'
 7477
 7478    def to_dict(self):
 7479        return {
 7480            'bind_interface': self.bind_interface,
 7481            'database': self.database,
 7482            'egress_filter': self.egress_filter,
 7483            'healthy': self.healthy,
 7484            'hostname': self.hostname,
 7485            'id': self.id,
 7486            'name': self.name,
 7487            'password': self.password,
 7488            'port': self.port,
 7489            'port_override': self.port_override,
 7490            'secret_store_id': self.secret_store_id,
 7491            'tags': self.tags,
 7492            'username': self.username,
 7493        }
 7494
 7495    @classmethod
 7496    def from_dict(cls, d):
 7497        return cls(
 7498            bind_interface=d.get('bind_interface'),
 7499            database=d.get('database'),
 7500            egress_filter=d.get('egress_filter'),
 7501            healthy=d.get('healthy'),
 7502            hostname=d.get('hostname'),
 7503            id=d.get('id'),
 7504            name=d.get('name'),
 7505            password=d.get('password'),
 7506            port=d.get('port'),
 7507            port_override=d.get('port_override'),
 7508            secret_store_id=d.get('secret_store_id'),
 7509            tags=d.get('tags'),
 7510            username=d.get('username'),
 7511        )
 7512
 7513
 7514class Memcached:
 7515    '''
 7516
 7517    '''
 7518    __slots__ = [
 7519        'bind_interface',
 7520        'egress_filter',
 7521        'healthy',
 7522        'hostname',
 7523        'id',
 7524        'name',
 7525        'port',
 7526        'port_override',
 7527        'secret_store_id',
 7528        'tags',
 7529    ]
 7530
 7531    def __init__(
 7532        self,
 7533        bind_interface=None,
 7534        egress_filter=None,
 7535        healthy=None,
 7536        hostname=None,
 7537        id=None,
 7538        name=None,
 7539        port=None,
 7540        port_override=None,
 7541        secret_store_id=None,
 7542        tags=None,
 7543    ):
 7544        self.bind_interface = bind_interface if bind_interface is not None else ''
 7545        '''
 7546         Bind interface
 7547        '''
 7548        self.egress_filter = egress_filter if egress_filter is not None else ''
 7549        '''
 7550         A filter applied to the routing logic to pin datasource to nodes.
 7551        '''
 7552        self.healthy = healthy if healthy is not None else False
 7553        '''
 7554         True if the datasource is reachable and the credentials are valid.
 7555        '''
 7556        self.hostname = hostname if hostname is not None else ''
 7557        '''
 7558
 7559        '''
 7560        self.id = id if id is not None else ''
 7561        '''
 7562         Unique identifier of the Resource.
 7563        '''
 7564        self.name = name if name is not None else ''
 7565        '''
 7566         Unique human-readable name of the Resource.
 7567        '''
 7568        self.port = port if port is not None else 0
 7569        '''
 7570
 7571        '''
 7572        self.port_override = port_override if port_override is not None else 0
 7573        '''
 7574
 7575        '''
 7576        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7577        '''
 7578         ID of the secret store containing credentials for this resource, if any.
 7579        '''
 7580        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7581        '''
 7582         Tags is a map of key, value pairs.
 7583        '''
 7584
 7585    def __repr__(self):
 7586        return '<sdm.Memcached ' + \
 7587            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7588            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7589            'healthy: ' + repr(self.healthy) + ' ' +\
 7590            'hostname: ' + repr(self.hostname) + ' ' +\
 7591            'id: ' + repr(self.id) + ' ' +\
 7592            'name: ' + repr(self.name) + ' ' +\
 7593            'port: ' + repr(self.port) + ' ' +\
 7594            'port_override: ' + repr(self.port_override) + ' ' +\
 7595            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7596            'tags: ' + repr(self.tags) + ' ' +\
 7597            '>'
 7598
 7599    def to_dict(self):
 7600        return {
 7601            'bind_interface': self.bind_interface,
 7602            'egress_filter': self.egress_filter,
 7603            'healthy': self.healthy,
 7604            'hostname': self.hostname,
 7605            'id': self.id,
 7606            'name': self.name,
 7607            'port': self.port,
 7608            'port_override': self.port_override,
 7609            'secret_store_id': self.secret_store_id,
 7610            'tags': self.tags,
 7611        }
 7612
 7613    @classmethod
 7614    def from_dict(cls, d):
 7615        return cls(
 7616            bind_interface=d.get('bind_interface'),
 7617            egress_filter=d.get('egress_filter'),
 7618            healthy=d.get('healthy'),
 7619            hostname=d.get('hostname'),
 7620            id=d.get('id'),
 7621            name=d.get('name'),
 7622            port=d.get('port'),
 7623            port_override=d.get('port_override'),
 7624            secret_store_id=d.get('secret_store_id'),
 7625            tags=d.get('tags'),
 7626        )
 7627
 7628
 7629class Memsql:
 7630    '''
 7631
 7632    '''
 7633    __slots__ = [
 7634        'bind_interface',
 7635        'database',
 7636        'egress_filter',
 7637        'healthy',
 7638        'hostname',
 7639        'id',
 7640        'name',
 7641        'password',
 7642        'port',
 7643        'port_override',
 7644        'secret_store_id',
 7645        'tags',
 7646        'username',
 7647    ]
 7648
 7649    def __init__(
 7650        self,
 7651        bind_interface=None,
 7652        database=None,
 7653        egress_filter=None,
 7654        healthy=None,
 7655        hostname=None,
 7656        id=None,
 7657        name=None,
 7658        password=None,
 7659        port=None,
 7660        port_override=None,
 7661        secret_store_id=None,
 7662        tags=None,
 7663        username=None,
 7664    ):
 7665        self.bind_interface = bind_interface if bind_interface is not None else ''
 7666        '''
 7667         Bind interface
 7668        '''
 7669        self.database = database if database is not None else ''
 7670        '''
 7671
 7672        '''
 7673        self.egress_filter = egress_filter if egress_filter is not None else ''
 7674        '''
 7675         A filter applied to the routing logic to pin datasource to nodes.
 7676        '''
 7677        self.healthy = healthy if healthy is not None else False
 7678        '''
 7679         True if the datasource is reachable and the credentials are valid.
 7680        '''
 7681        self.hostname = hostname if hostname is not None else ''
 7682        '''
 7683
 7684        '''
 7685        self.id = id if id is not None else ''
 7686        '''
 7687         Unique identifier of the Resource.
 7688        '''
 7689        self.name = name if name is not None else ''
 7690        '''
 7691         Unique human-readable name of the Resource.
 7692        '''
 7693        self.password = password if password is not None else ''
 7694        '''
 7695
 7696        '''
 7697        self.port = port if port is not None else 0
 7698        '''
 7699
 7700        '''
 7701        self.port_override = port_override if port_override is not None else 0
 7702        '''
 7703
 7704        '''
 7705        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7706        '''
 7707         ID of the secret store containing credentials for this resource, if any.
 7708        '''
 7709        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7710        '''
 7711         Tags is a map of key, value pairs.
 7712        '''
 7713        self.username = username if username is not None else ''
 7714        '''
 7715
 7716        '''
 7717
 7718    def __repr__(self):
 7719        return '<sdm.Memsql ' + \
 7720            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7721            'database: ' + repr(self.database) + ' ' +\
 7722            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7723            'healthy: ' + repr(self.healthy) + ' ' +\
 7724            'hostname: ' + repr(self.hostname) + ' ' +\
 7725            'id: ' + repr(self.id) + ' ' +\
 7726            'name: ' + repr(self.name) + ' ' +\
 7727            'password: ' + repr(self.password) + ' ' +\
 7728            'port: ' + repr(self.port) + ' ' +\
 7729            'port_override: ' + repr(self.port_override) + ' ' +\
 7730            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7731            'tags: ' + repr(self.tags) + ' ' +\
 7732            'username: ' + repr(self.username) + ' ' +\
 7733            '>'
 7734
 7735    def to_dict(self):
 7736        return {
 7737            'bind_interface': self.bind_interface,
 7738            'database': self.database,
 7739            'egress_filter': self.egress_filter,
 7740            'healthy': self.healthy,
 7741            'hostname': self.hostname,
 7742            'id': self.id,
 7743            'name': self.name,
 7744            'password': self.password,
 7745            'port': self.port,
 7746            'port_override': self.port_override,
 7747            'secret_store_id': self.secret_store_id,
 7748            'tags': self.tags,
 7749            'username': self.username,
 7750        }
 7751
 7752    @classmethod
 7753    def from_dict(cls, d):
 7754        return cls(
 7755            bind_interface=d.get('bind_interface'),
 7756            database=d.get('database'),
 7757            egress_filter=d.get('egress_filter'),
 7758            healthy=d.get('healthy'),
 7759            hostname=d.get('hostname'),
 7760            id=d.get('id'),
 7761            name=d.get('name'),
 7762            password=d.get('password'),
 7763            port=d.get('port'),
 7764            port_override=d.get('port_override'),
 7765            secret_store_id=d.get('secret_store_id'),
 7766            tags=d.get('tags'),
 7767            username=d.get('username'),
 7768        )
 7769
 7770
 7771class MongoHost:
 7772    '''
 7773
 7774    '''
 7775    __slots__ = [
 7776        'auth_database',
 7777        'bind_interface',
 7778        'egress_filter',
 7779        'healthy',
 7780        'hostname',
 7781        'id',
 7782        'name',
 7783        'password',
 7784        'port',
 7785        'port_override',
 7786        'secret_store_id',
 7787        'tags',
 7788        'tls_required',
 7789        'username',
 7790    ]
 7791
 7792    def __init__(
 7793        self,
 7794        auth_database=None,
 7795        bind_interface=None,
 7796        egress_filter=None,
 7797        healthy=None,
 7798        hostname=None,
 7799        id=None,
 7800        name=None,
 7801        password=None,
 7802        port=None,
 7803        port_override=None,
 7804        secret_store_id=None,
 7805        tags=None,
 7806        tls_required=None,
 7807        username=None,
 7808    ):
 7809        self.auth_database = auth_database if auth_database is not None else ''
 7810        '''
 7811
 7812        '''
 7813        self.bind_interface = bind_interface if bind_interface is not None else ''
 7814        '''
 7815         Bind interface
 7816        '''
 7817        self.egress_filter = egress_filter if egress_filter is not None else ''
 7818        '''
 7819         A filter applied to the routing logic to pin datasource to nodes.
 7820        '''
 7821        self.healthy = healthy if healthy is not None else False
 7822        '''
 7823         True if the datasource is reachable and the credentials are valid.
 7824        '''
 7825        self.hostname = hostname if hostname is not None else ''
 7826        '''
 7827
 7828        '''
 7829        self.id = id if id is not None else ''
 7830        '''
 7831         Unique identifier of the Resource.
 7832        '''
 7833        self.name = name if name is not None else ''
 7834        '''
 7835         Unique human-readable name of the Resource.
 7836        '''
 7837        self.password = password if password is not None else ''
 7838        '''
 7839
 7840        '''
 7841        self.port = port if port is not None else 0
 7842        '''
 7843
 7844        '''
 7845        self.port_override = port_override if port_override is not None else 0
 7846        '''
 7847
 7848        '''
 7849        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7850        '''
 7851         ID of the secret store containing credentials for this resource, if any.
 7852        '''
 7853        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7854        '''
 7855         Tags is a map of key, value pairs.
 7856        '''
 7857        self.tls_required = tls_required if tls_required is not None else False
 7858        '''
 7859
 7860        '''
 7861        self.username = username if username is not None else ''
 7862        '''
 7863
 7864        '''
 7865
 7866    def __repr__(self):
 7867        return '<sdm.MongoHost ' + \
 7868            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7869            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7870            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7871            'healthy: ' + repr(self.healthy) + ' ' +\
 7872            'hostname: ' + repr(self.hostname) + ' ' +\
 7873            'id: ' + repr(self.id) + ' ' +\
 7874            'name: ' + repr(self.name) + ' ' +\
 7875            'password: ' + repr(self.password) + ' ' +\
 7876            'port: ' + repr(self.port) + ' ' +\
 7877            'port_override: ' + repr(self.port_override) + ' ' +\
 7878            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7879            'tags: ' + repr(self.tags) + ' ' +\
 7880            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7881            'username: ' + repr(self.username) + ' ' +\
 7882            '>'
 7883
 7884    def to_dict(self):
 7885        return {
 7886            'auth_database': self.auth_database,
 7887            'bind_interface': self.bind_interface,
 7888            'egress_filter': self.egress_filter,
 7889            'healthy': self.healthy,
 7890            'hostname': self.hostname,
 7891            'id': self.id,
 7892            'name': self.name,
 7893            'password': self.password,
 7894            'port': self.port,
 7895            'port_override': self.port_override,
 7896            'secret_store_id': self.secret_store_id,
 7897            'tags': self.tags,
 7898            'tls_required': self.tls_required,
 7899            'username': self.username,
 7900        }
 7901
 7902    @classmethod
 7903    def from_dict(cls, d):
 7904        return cls(
 7905            auth_database=d.get('auth_database'),
 7906            bind_interface=d.get('bind_interface'),
 7907            egress_filter=d.get('egress_filter'),
 7908            healthy=d.get('healthy'),
 7909            hostname=d.get('hostname'),
 7910            id=d.get('id'),
 7911            name=d.get('name'),
 7912            password=d.get('password'),
 7913            port=d.get('port'),
 7914            port_override=d.get('port_override'),
 7915            secret_store_id=d.get('secret_store_id'),
 7916            tags=d.get('tags'),
 7917            tls_required=d.get('tls_required'),
 7918            username=d.get('username'),
 7919        )
 7920
 7921
 7922class MongoLegacyHost:
 7923    '''
 7924
 7925    '''
 7926    __slots__ = [
 7927        'auth_database',
 7928        'bind_interface',
 7929        'egress_filter',
 7930        'healthy',
 7931        'hostname',
 7932        'id',
 7933        'name',
 7934        'password',
 7935        'port',
 7936        'port_override',
 7937        'replica_set',
 7938        'secret_store_id',
 7939        'tags',
 7940        'tls_required',
 7941        'username',
 7942    ]
 7943
 7944    def __init__(
 7945        self,
 7946        auth_database=None,
 7947        bind_interface=None,
 7948        egress_filter=None,
 7949        healthy=None,
 7950        hostname=None,
 7951        id=None,
 7952        name=None,
 7953        password=None,
 7954        port=None,
 7955        port_override=None,
 7956        replica_set=None,
 7957        secret_store_id=None,
 7958        tags=None,
 7959        tls_required=None,
 7960        username=None,
 7961    ):
 7962        self.auth_database = auth_database if auth_database is not None else ''
 7963        '''
 7964
 7965        '''
 7966        self.bind_interface = bind_interface if bind_interface is not None else ''
 7967        '''
 7968         Bind interface
 7969        '''
 7970        self.egress_filter = egress_filter if egress_filter is not None else ''
 7971        '''
 7972         A filter applied to the routing logic to pin datasource to nodes.
 7973        '''
 7974        self.healthy = healthy if healthy is not None else False
 7975        '''
 7976         True if the datasource is reachable and the credentials are valid.
 7977        '''
 7978        self.hostname = hostname if hostname is not None else ''
 7979        '''
 7980
 7981        '''
 7982        self.id = id if id is not None else ''
 7983        '''
 7984         Unique identifier of the Resource.
 7985        '''
 7986        self.name = name if name is not None else ''
 7987        '''
 7988         Unique human-readable name of the Resource.
 7989        '''
 7990        self.password = password if password is not None else ''
 7991        '''
 7992
 7993        '''
 7994        self.port = port if port is not None else 0
 7995        '''
 7996
 7997        '''
 7998        self.port_override = port_override if port_override is not None else 0
 7999        '''
 8000
 8001        '''
 8002        self.replica_set = replica_set if replica_set is not None else ''
 8003        '''
 8004
 8005        '''
 8006        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8007        '''
 8008         ID of the secret store containing credentials for this resource, if any.
 8009        '''
 8010        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8011        '''
 8012         Tags is a map of key, value pairs.
 8013        '''
 8014        self.tls_required = tls_required if tls_required is not None else False
 8015        '''
 8016
 8017        '''
 8018        self.username = username if username is not None else ''
 8019        '''
 8020
 8021        '''
 8022
 8023    def __repr__(self):
 8024        return '<sdm.MongoLegacyHost ' + \
 8025            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8026            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8027            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8028            'healthy: ' + repr(self.healthy) + ' ' +\
 8029            'hostname: ' + repr(self.hostname) + ' ' +\
 8030            'id: ' + repr(self.id) + ' ' +\
 8031            'name: ' + repr(self.name) + ' ' +\
 8032            'password: ' + repr(self.password) + ' ' +\
 8033            'port: ' + repr(self.port) + ' ' +\
 8034            'port_override: ' + repr(self.port_override) + ' ' +\
 8035            'replica_set: ' + repr(self.replica_set) + ' ' +\
 8036            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8037            'tags: ' + repr(self.tags) + ' ' +\
 8038            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8039            'username: ' + repr(self.username) + ' ' +\
 8040            '>'
 8041
 8042    def to_dict(self):
 8043        return {
 8044            'auth_database': self.auth_database,
 8045            'bind_interface': self.bind_interface,
 8046            'egress_filter': self.egress_filter,
 8047            'healthy': self.healthy,
 8048            'hostname': self.hostname,
 8049            'id': self.id,
 8050            'name': self.name,
 8051            'password': self.password,
 8052            'port': self.port,
 8053            'port_override': self.port_override,
 8054            'replica_set': self.replica_set,
 8055            'secret_store_id': self.secret_store_id,
 8056            'tags': self.tags,
 8057            'tls_required': self.tls_required,
 8058            'username': self.username,
 8059        }
 8060
 8061    @classmethod
 8062    def from_dict(cls, d):
 8063        return cls(
 8064            auth_database=d.get('auth_database'),
 8065            bind_interface=d.get('bind_interface'),
 8066            egress_filter=d.get('egress_filter'),
 8067            healthy=d.get('healthy'),
 8068            hostname=d.get('hostname'),
 8069            id=d.get('id'),
 8070            name=d.get('name'),
 8071            password=d.get('password'),
 8072            port=d.get('port'),
 8073            port_override=d.get('port_override'),
 8074            replica_set=d.get('replica_set'),
 8075            secret_store_id=d.get('secret_store_id'),
 8076            tags=d.get('tags'),
 8077            tls_required=d.get('tls_required'),
 8078            username=d.get('username'),
 8079        )
 8080
 8081
 8082class MongoLegacyReplicaset:
 8083    '''
 8084
 8085    '''
 8086    __slots__ = [
 8087        'auth_database',
 8088        'bind_interface',
 8089        'connect_to_replica',
 8090        'egress_filter',
 8091        'healthy',
 8092        'hostname',
 8093        'id',
 8094        'name',
 8095        'password',
 8096        'port',
 8097        'port_override',
 8098        'replica_set',
 8099        'secret_store_id',
 8100        'tags',
 8101        'tls_required',
 8102        'username',
 8103    ]
 8104
 8105    def __init__(
 8106        self,
 8107        auth_database=None,
 8108        bind_interface=None,
 8109        connect_to_replica=None,
 8110        egress_filter=None,
 8111        healthy=None,
 8112        hostname=None,
 8113        id=None,
 8114        name=None,
 8115        password=None,
 8116        port=None,
 8117        port_override=None,
 8118        replica_set=None,
 8119        secret_store_id=None,
 8120        tags=None,
 8121        tls_required=None,
 8122        username=None,
 8123    ):
 8124        self.auth_database = auth_database if auth_database is not None else ''
 8125        '''
 8126
 8127        '''
 8128        self.bind_interface = bind_interface if bind_interface is not None else ''
 8129        '''
 8130         Bind interface
 8131        '''
 8132        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 8133        '''
 8134
 8135        '''
 8136        self.egress_filter = egress_filter if egress_filter is not None else ''
 8137        '''
 8138         A filter applied to the routing logic to pin datasource to nodes.
 8139        '''
 8140        self.healthy = healthy if healthy is not None else False
 8141        '''
 8142         True if the datasource is reachable and the credentials are valid.
 8143        '''
 8144        self.hostname = hostname if hostname is not None else ''
 8145        '''
 8146
 8147        '''
 8148        self.id = id if id is not None else ''
 8149        '''
 8150         Unique identifier of the Resource.
 8151        '''
 8152        self.name = name if name is not None else ''
 8153        '''
 8154         Unique human-readable name of the Resource.
 8155        '''
 8156        self.password = password if password is not None else ''
 8157        '''
 8158
 8159        '''
 8160        self.port = port if port is not None else 0
 8161        '''
 8162
 8163        '''
 8164        self.port_override = port_override if port_override is not None else 0
 8165        '''
 8166
 8167        '''
 8168        self.replica_set = replica_set if replica_set is not None else ''
 8169        '''
 8170
 8171        '''
 8172        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8173        '''
 8174         ID of the secret store containing credentials for this resource, if any.
 8175        '''
 8176        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8177        '''
 8178         Tags is a map of key, value pairs.
 8179        '''
 8180        self.tls_required = tls_required if tls_required is not None else False
 8181        '''
 8182
 8183        '''
 8184        self.username = username if username is not None else ''
 8185        '''
 8186
 8187        '''
 8188
 8189    def __repr__(self):
 8190        return '<sdm.MongoLegacyReplicaset ' + \
 8191            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8192            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8193            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 8194            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8195            'healthy: ' + repr(self.healthy) + ' ' +\
 8196            'hostname: ' + repr(self.hostname) + ' ' +\
 8197            'id: ' + repr(self.id) + ' ' +\
 8198            'name: ' + repr(self.name) + ' ' +\
 8199            'password: ' + repr(self.password) + ' ' +\
 8200            'port: ' + repr(self.port) + ' ' +\
 8201            'port_override: ' + repr(self.port_override) + ' ' +\
 8202            'replica_set: ' + repr(self.replica_set) + ' ' +\
 8203            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8204            'tags: ' + repr(self.tags) + ' ' +\
 8205            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8206            'username: ' + repr(self.username) + ' ' +\
 8207            '>'
 8208
 8209    def to_dict(self):
 8210        return {
 8211            'auth_database': self.auth_database,
 8212            'bind_interface': self.bind_interface,
 8213            'connect_to_replica': self.connect_to_replica,
 8214            'egress_filter': self.egress_filter,
 8215            'healthy': self.healthy,
 8216            'hostname': self.hostname,
 8217            'id': self.id,
 8218            'name': self.name,
 8219            'password': self.password,
 8220            'port': self.port,
 8221            'port_override': self.port_override,
 8222            'replica_set': self.replica_set,
 8223            'secret_store_id': self.secret_store_id,
 8224            'tags': self.tags,
 8225            'tls_required': self.tls_required,
 8226            'username': self.username,
 8227        }
 8228
 8229    @classmethod
 8230    def from_dict(cls, d):
 8231        return cls(
 8232            auth_database=d.get('auth_database'),
 8233            bind_interface=d.get('bind_interface'),
 8234            connect_to_replica=d.get('connect_to_replica'),
 8235            egress_filter=d.get('egress_filter'),
 8236            healthy=d.get('healthy'),
 8237            hostname=d.get('hostname'),
 8238            id=d.get('id'),
 8239            name=d.get('name'),
 8240            password=d.get('password'),
 8241            port=d.get('port'),
 8242            port_override=d.get('port_override'),
 8243            replica_set=d.get('replica_set'),
 8244            secret_store_id=d.get('secret_store_id'),
 8245            tags=d.get('tags'),
 8246            tls_required=d.get('tls_required'),
 8247            username=d.get('username'),
 8248        )
 8249
 8250
 8251class MongoReplicaSet:
 8252    '''
 8253
 8254    '''
 8255    __slots__ = [
 8256        'auth_database',
 8257        'bind_interface',
 8258        'connect_to_replica',
 8259        'egress_filter',
 8260        'healthy',
 8261        'hostname',
 8262        'id',
 8263        'name',
 8264        'password',
 8265        'port',
 8266        'port_override',
 8267        'replica_set',
 8268        'secret_store_id',
 8269        'tags',
 8270        'tls_required',
 8271        'username',
 8272    ]
 8273
 8274    def __init__(
 8275        self,
 8276        auth_database=None,
 8277        bind_interface=None,
 8278        connect_to_replica=None,
 8279        egress_filter=None,
 8280        healthy=None,
 8281        hostname=None,
 8282        id=None,
 8283        name=None,
 8284        password=None,
 8285        port=None,
 8286        port_override=None,
 8287        replica_set=None,
 8288        secret_store_id=None,
 8289        tags=None,
 8290        tls_required=None,
 8291        username=None,
 8292    ):
 8293        self.auth_database = auth_database if auth_database is not None else ''
 8294        '''
 8295
 8296        '''
 8297        self.bind_interface = bind_interface if bind_interface is not None else ''
 8298        '''
 8299         Bind interface
 8300        '''
 8301        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 8302        '''
 8303
 8304        '''
 8305        self.egress_filter = egress_filter if egress_filter is not None else ''
 8306        '''
 8307         A filter applied to the routing logic to pin datasource to nodes.
 8308        '''
 8309        self.healthy = healthy if healthy is not None else False
 8310        '''
 8311         True if the datasource is reachable and the credentials are valid.
 8312        '''
 8313        self.hostname = hostname if hostname is not None else ''
 8314        '''
 8315
 8316        '''
 8317        self.id = id if id is not None else ''
 8318        '''
 8319         Unique identifier of the Resource.
 8320        '''
 8321        self.name = name if name is not None else ''
 8322        '''
 8323         Unique human-readable name of the Resource.
 8324        '''
 8325        self.password = password if password is not None else ''
 8326        '''
 8327
 8328        '''
 8329        self.port = port if port is not None else 0
 8330        '''
 8331
 8332        '''
 8333        self.port_override = port_override if port_override is not None else 0
 8334        '''
 8335
 8336        '''
 8337        self.replica_set = replica_set if replica_set is not None else ''
 8338        '''
 8339
 8340        '''
 8341        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8342        '''
 8343         ID of the secret store containing credentials for this resource, if any.
 8344        '''
 8345        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8346        '''
 8347         Tags is a map of key, value pairs.
 8348        '''
 8349        self.tls_required = tls_required if tls_required is not None else False
 8350        '''
 8351
 8352        '''
 8353        self.username = username if username is not None else ''
 8354        '''
 8355
 8356        '''
 8357
 8358    def __repr__(self):
 8359        return '<sdm.MongoReplicaSet ' + \
 8360            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8361            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8362            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 8363            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8364            'healthy: ' + repr(self.healthy) + ' ' +\
 8365            'hostname: ' + repr(self.hostname) + ' ' +\
 8366            'id: ' + repr(self.id) + ' ' +\
 8367            'name: ' + repr(self.name) + ' ' +\
 8368            'password: ' + repr(self.password) + ' ' +\
 8369            'port: ' + repr(self.port) + ' ' +\
 8370            'port_override: ' + repr(self.port_override) + ' ' +\
 8371            'replica_set: ' + repr(self.replica_set) + ' ' +\
 8372            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8373            'tags: ' + repr(self.tags) + ' ' +\
 8374            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8375            'username: ' + repr(self.username) + ' ' +\
 8376            '>'
 8377
 8378    def to_dict(self):
 8379        return {
 8380            'auth_database': self.auth_database,
 8381            'bind_interface': self.bind_interface,
 8382            'connect_to_replica': self.connect_to_replica,
 8383            'egress_filter': self.egress_filter,
 8384            'healthy': self.healthy,
 8385            'hostname': self.hostname,
 8386            'id': self.id,
 8387            'name': self.name,
 8388            'password': self.password,
 8389            'port': self.port,
 8390            'port_override': self.port_override,
 8391            'replica_set': self.replica_set,
 8392            'secret_store_id': self.secret_store_id,
 8393            'tags': self.tags,
 8394            'tls_required': self.tls_required,
 8395            'username': self.username,
 8396        }
 8397
 8398    @classmethod
 8399    def from_dict(cls, d):
 8400        return cls(
 8401            auth_database=d.get('auth_database'),
 8402            bind_interface=d.get('bind_interface'),
 8403            connect_to_replica=d.get('connect_to_replica'),
 8404            egress_filter=d.get('egress_filter'),
 8405            healthy=d.get('healthy'),
 8406            hostname=d.get('hostname'),
 8407            id=d.get('id'),
 8408            name=d.get('name'),
 8409            password=d.get('password'),
 8410            port=d.get('port'),
 8411            port_override=d.get('port_override'),
 8412            replica_set=d.get('replica_set'),
 8413            secret_store_id=d.get('secret_store_id'),
 8414            tags=d.get('tags'),
 8415            tls_required=d.get('tls_required'),
 8416            username=d.get('username'),
 8417        )
 8418
 8419
 8420class MongoShardedCluster:
 8421    '''
 8422
 8423    '''
 8424    __slots__ = [
 8425        'auth_database',
 8426        'bind_interface',
 8427        'egress_filter',
 8428        'healthy',
 8429        'hostname',
 8430        'id',
 8431        'name',
 8432        'password',
 8433        'port_override',
 8434        'secret_store_id',
 8435        'tags',
 8436        'tls_required',
 8437        'username',
 8438    ]
 8439
 8440    def __init__(
 8441        self,
 8442        auth_database=None,
 8443        bind_interface=None,
 8444        egress_filter=None,
 8445        healthy=None,
 8446        hostname=None,
 8447        id=None,
 8448        name=None,
 8449        password=None,
 8450        port_override=None,
 8451        secret_store_id=None,
 8452        tags=None,
 8453        tls_required=None,
 8454        username=None,
 8455    ):
 8456        self.auth_database = auth_database if auth_database is not None else ''
 8457        '''
 8458
 8459        '''
 8460        self.bind_interface = bind_interface if bind_interface is not None else ''
 8461        '''
 8462         Bind interface
 8463        '''
 8464        self.egress_filter = egress_filter if egress_filter is not None else ''
 8465        '''
 8466         A filter applied to the routing logic to pin datasource to nodes.
 8467        '''
 8468        self.healthy = healthy if healthy is not None else False
 8469        '''
 8470         True if the datasource is reachable and the credentials are valid.
 8471        '''
 8472        self.hostname = hostname if hostname is not None else ''
 8473        '''
 8474
 8475        '''
 8476        self.id = id if id is not None else ''
 8477        '''
 8478         Unique identifier of the Resource.
 8479        '''
 8480        self.name = name if name is not None else ''
 8481        '''
 8482         Unique human-readable name of the Resource.
 8483        '''
 8484        self.password = password if password is not None else ''
 8485        '''
 8486
 8487        '''
 8488        self.port_override = port_override if port_override is not None else 0
 8489        '''
 8490
 8491        '''
 8492        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8493        '''
 8494         ID of the secret store containing credentials for this resource, if any.
 8495        '''
 8496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8497        '''
 8498         Tags is a map of key, value pairs.
 8499        '''
 8500        self.tls_required = tls_required if tls_required is not None else False
 8501        '''
 8502
 8503        '''
 8504        self.username = username if username is not None else ''
 8505        '''
 8506
 8507        '''
 8508
 8509    def __repr__(self):
 8510        return '<sdm.MongoShardedCluster ' + \
 8511            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8512            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8513            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8514            'healthy: ' + repr(self.healthy) + ' ' +\
 8515            'hostname: ' + repr(self.hostname) + ' ' +\
 8516            'id: ' + repr(self.id) + ' ' +\
 8517            'name: ' + repr(self.name) + ' ' +\
 8518            'password: ' + repr(self.password) + ' ' +\
 8519            'port_override: ' + repr(self.port_override) + ' ' +\
 8520            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8521            'tags: ' + repr(self.tags) + ' ' +\
 8522            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8523            'username: ' + repr(self.username) + ' ' +\
 8524            '>'
 8525
 8526    def to_dict(self):
 8527        return {
 8528            'auth_database': self.auth_database,
 8529            'bind_interface': self.bind_interface,
 8530            'egress_filter': self.egress_filter,
 8531            'healthy': self.healthy,
 8532            'hostname': self.hostname,
 8533            'id': self.id,
 8534            'name': self.name,
 8535            'password': self.password,
 8536            'port_override': self.port_override,
 8537            'secret_store_id': self.secret_store_id,
 8538            'tags': self.tags,
 8539            'tls_required': self.tls_required,
 8540            'username': self.username,
 8541        }
 8542
 8543    @classmethod
 8544    def from_dict(cls, d):
 8545        return cls(
 8546            auth_database=d.get('auth_database'),
 8547            bind_interface=d.get('bind_interface'),
 8548            egress_filter=d.get('egress_filter'),
 8549            healthy=d.get('healthy'),
 8550            hostname=d.get('hostname'),
 8551            id=d.get('id'),
 8552            name=d.get('name'),
 8553            password=d.get('password'),
 8554            port_override=d.get('port_override'),
 8555            secret_store_id=d.get('secret_store_id'),
 8556            tags=d.get('tags'),
 8557            tls_required=d.get('tls_required'),
 8558            username=d.get('username'),
 8559        )
 8560
 8561
 8562class Mysql:
 8563    '''
 8564
 8565    '''
 8566    __slots__ = [
 8567        'bind_interface',
 8568        'database',
 8569        'egress_filter',
 8570        'healthy',
 8571        'hostname',
 8572        'id',
 8573        'name',
 8574        'password',
 8575        'port',
 8576        'port_override',
 8577        'secret_store_id',
 8578        'tags',
 8579        'username',
 8580    ]
 8581
 8582    def __init__(
 8583        self,
 8584        bind_interface=None,
 8585        database=None,
 8586        egress_filter=None,
 8587        healthy=None,
 8588        hostname=None,
 8589        id=None,
 8590        name=None,
 8591        password=None,
 8592        port=None,
 8593        port_override=None,
 8594        secret_store_id=None,
 8595        tags=None,
 8596        username=None,
 8597    ):
 8598        self.bind_interface = bind_interface if bind_interface is not None else ''
 8599        '''
 8600         Bind interface
 8601        '''
 8602        self.database = database if database is not None else ''
 8603        '''
 8604
 8605        '''
 8606        self.egress_filter = egress_filter if egress_filter is not None else ''
 8607        '''
 8608         A filter applied to the routing logic to pin datasource to nodes.
 8609        '''
 8610        self.healthy = healthy if healthy is not None else False
 8611        '''
 8612         True if the datasource is reachable and the credentials are valid.
 8613        '''
 8614        self.hostname = hostname if hostname is not None else ''
 8615        '''
 8616
 8617        '''
 8618        self.id = id if id is not None else ''
 8619        '''
 8620         Unique identifier of the Resource.
 8621        '''
 8622        self.name = name if name is not None else ''
 8623        '''
 8624         Unique human-readable name of the Resource.
 8625        '''
 8626        self.password = password if password is not None else ''
 8627        '''
 8628
 8629        '''
 8630        self.port = port if port is not None else 0
 8631        '''
 8632
 8633        '''
 8634        self.port_override = port_override if port_override is not None else 0
 8635        '''
 8636
 8637        '''
 8638        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8639        '''
 8640         ID of the secret store containing credentials for this resource, if any.
 8641        '''
 8642        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8643        '''
 8644         Tags is a map of key, value pairs.
 8645        '''
 8646        self.username = username if username is not None else ''
 8647        '''
 8648
 8649        '''
 8650
 8651    def __repr__(self):
 8652        return '<sdm.Mysql ' + \
 8653            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8654            'database: ' + repr(self.database) + ' ' +\
 8655            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8656            'healthy: ' + repr(self.healthy) + ' ' +\
 8657            'hostname: ' + repr(self.hostname) + ' ' +\
 8658            'id: ' + repr(self.id) + ' ' +\
 8659            'name: ' + repr(self.name) + ' ' +\
 8660            'password: ' + repr(self.password) + ' ' +\
 8661            'port: ' + repr(self.port) + ' ' +\
 8662            'port_override: ' + repr(self.port_override) + ' ' +\
 8663            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8664            'tags: ' + repr(self.tags) + ' ' +\
 8665            'username: ' + repr(self.username) + ' ' +\
 8666            '>'
 8667
 8668    def to_dict(self):
 8669        return {
 8670            'bind_interface': self.bind_interface,
 8671            'database': self.database,
 8672            'egress_filter': self.egress_filter,
 8673            'healthy': self.healthy,
 8674            'hostname': self.hostname,
 8675            'id': self.id,
 8676            'name': self.name,
 8677            'password': self.password,
 8678            'port': self.port,
 8679            'port_override': self.port_override,
 8680            'secret_store_id': self.secret_store_id,
 8681            'tags': self.tags,
 8682            'username': self.username,
 8683        }
 8684
 8685    @classmethod
 8686    def from_dict(cls, d):
 8687        return cls(
 8688            bind_interface=d.get('bind_interface'),
 8689            database=d.get('database'),
 8690            egress_filter=d.get('egress_filter'),
 8691            healthy=d.get('healthy'),
 8692            hostname=d.get('hostname'),
 8693            id=d.get('id'),
 8694            name=d.get('name'),
 8695            password=d.get('password'),
 8696            port=d.get('port'),
 8697            port_override=d.get('port_override'),
 8698            secret_store_id=d.get('secret_store_id'),
 8699            tags=d.get('tags'),
 8700            username=d.get('username'),
 8701        )
 8702
 8703
 8704class Neptune:
 8705    '''
 8706
 8707    '''
 8708    __slots__ = [
 8709        'bind_interface',
 8710        'egress_filter',
 8711        'endpoint',
 8712        'healthy',
 8713        'id',
 8714        'name',
 8715        'port',
 8716        'port_override',
 8717        'secret_store_id',
 8718        'tags',
 8719    ]
 8720
 8721    def __init__(
 8722        self,
 8723        bind_interface=None,
 8724        egress_filter=None,
 8725        endpoint=None,
 8726        healthy=None,
 8727        id=None,
 8728        name=None,
 8729        port=None,
 8730        port_override=None,
 8731        secret_store_id=None,
 8732        tags=None,
 8733    ):
 8734        self.bind_interface = bind_interface if bind_interface is not None else ''
 8735        '''
 8736         Bind interface
 8737        '''
 8738        self.egress_filter = egress_filter if egress_filter is not None else ''
 8739        '''
 8740         A filter applied to the routing logic to pin datasource to nodes.
 8741        '''
 8742        self.endpoint = endpoint if endpoint is not None else ''
 8743        '''
 8744
 8745        '''
 8746        self.healthy = healthy if healthy is not None else False
 8747        '''
 8748         True if the datasource is reachable and the credentials are valid.
 8749        '''
 8750        self.id = id if id is not None else ''
 8751        '''
 8752         Unique identifier of the Resource.
 8753        '''
 8754        self.name = name if name is not None else ''
 8755        '''
 8756         Unique human-readable name of the Resource.
 8757        '''
 8758        self.port = port if port is not None else 0
 8759        '''
 8760
 8761        '''
 8762        self.port_override = port_override if port_override is not None else 0
 8763        '''
 8764
 8765        '''
 8766        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8767        '''
 8768         ID of the secret store containing credentials for this resource, if any.
 8769        '''
 8770        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8771        '''
 8772         Tags is a map of key, value pairs.
 8773        '''
 8774
 8775    def __repr__(self):
 8776        return '<sdm.Neptune ' + \
 8777            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8778            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8779            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8780            'healthy: ' + repr(self.healthy) + ' ' +\
 8781            'id: ' + repr(self.id) + ' ' +\
 8782            'name: ' + repr(self.name) + ' ' +\
 8783            'port: ' + repr(self.port) + ' ' +\
 8784            'port_override: ' + repr(self.port_override) + ' ' +\
 8785            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8786            'tags: ' + repr(self.tags) + ' ' +\
 8787            '>'
 8788
 8789    def to_dict(self):
 8790        return {
 8791            'bind_interface': self.bind_interface,
 8792            'egress_filter': self.egress_filter,
 8793            'endpoint': self.endpoint,
 8794            'healthy': self.healthy,
 8795            'id': self.id,
 8796            'name': self.name,
 8797            'port': self.port,
 8798            'port_override': self.port_override,
 8799            'secret_store_id': self.secret_store_id,
 8800            'tags': self.tags,
 8801        }
 8802
 8803    @classmethod
 8804    def from_dict(cls, d):
 8805        return cls(
 8806            bind_interface=d.get('bind_interface'),
 8807            egress_filter=d.get('egress_filter'),
 8808            endpoint=d.get('endpoint'),
 8809            healthy=d.get('healthy'),
 8810            id=d.get('id'),
 8811            name=d.get('name'),
 8812            port=d.get('port'),
 8813            port_override=d.get('port_override'),
 8814            secret_store_id=d.get('secret_store_id'),
 8815            tags=d.get('tags'),
 8816        )
 8817
 8818
 8819class NeptuneIAM:
 8820    '''
 8821
 8822    '''
 8823    __slots__ = [
 8824        'access_key',
 8825        'bind_interface',
 8826        'egress_filter',
 8827        'endpoint',
 8828        'healthy',
 8829        'id',
 8830        'name',
 8831        'port',
 8832        'port_override',
 8833        'region',
 8834        'role_arn',
 8835        'role_external_id',
 8836        'secret_access_key',
 8837        'secret_store_id',
 8838        'tags',
 8839    ]
 8840
 8841    def __init__(
 8842        self,
 8843        access_key=None,
 8844        bind_interface=None,
 8845        egress_filter=None,
 8846        endpoint=None,
 8847        healthy=None,
 8848        id=None,
 8849        name=None,
 8850        port=None,
 8851        port_override=None,
 8852        region=None,
 8853        role_arn=None,
 8854        role_external_id=None,
 8855        secret_access_key=None,
 8856        secret_store_id=None,
 8857        tags=None,
 8858    ):
 8859        self.access_key = access_key if access_key is not None else ''
 8860        '''
 8861
 8862        '''
 8863        self.bind_interface = bind_interface if bind_interface is not None else ''
 8864        '''
 8865         Bind interface
 8866        '''
 8867        self.egress_filter = egress_filter if egress_filter is not None else ''
 8868        '''
 8869         A filter applied to the routing logic to pin datasource to nodes.
 8870        '''
 8871        self.endpoint = endpoint if endpoint is not None else ''
 8872        '''
 8873
 8874        '''
 8875        self.healthy = healthy if healthy is not None else False
 8876        '''
 8877         True if the datasource is reachable and the credentials are valid.
 8878        '''
 8879        self.id = id if id is not None else ''
 8880        '''
 8881         Unique identifier of the Resource.
 8882        '''
 8883        self.name = name if name is not None else ''
 8884        '''
 8885         Unique human-readable name of the Resource.
 8886        '''
 8887        self.port = port if port is not None else 0
 8888        '''
 8889
 8890        '''
 8891        self.port_override = port_override if port_override is not None else 0
 8892        '''
 8893
 8894        '''
 8895        self.region = region if region is not None else ''
 8896        '''
 8897
 8898        '''
 8899        self.role_arn = role_arn if role_arn is not None else ''
 8900        '''
 8901
 8902        '''
 8903        self.role_external_id = role_external_id if role_external_id is not None else ''
 8904        '''
 8905
 8906        '''
 8907        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 8908        '''
 8909
 8910        '''
 8911        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8912        '''
 8913         ID of the secret store containing credentials for this resource, if any.
 8914        '''
 8915        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8916        '''
 8917         Tags is a map of key, value pairs.
 8918        '''
 8919
 8920    def __repr__(self):
 8921        return '<sdm.NeptuneIAM ' + \
 8922            'access_key: ' + repr(self.access_key) + ' ' +\
 8923            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8924            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8925            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8926            'healthy: ' + repr(self.healthy) + ' ' +\
 8927            'id: ' + repr(self.id) + ' ' +\
 8928            'name: ' + repr(self.name) + ' ' +\
 8929            'port: ' + repr(self.port) + ' ' +\
 8930            'port_override: ' + repr(self.port_override) + ' ' +\
 8931            'region: ' + repr(self.region) + ' ' +\
 8932            'role_arn: ' + repr(self.role_arn) + ' ' +\
 8933            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 8934            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 8935            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8936            'tags: ' + repr(self.tags) + ' ' +\
 8937            '>'
 8938
 8939    def to_dict(self):
 8940        return {
 8941            'access_key': self.access_key,
 8942            'bind_interface': self.bind_interface,
 8943            'egress_filter': self.egress_filter,
 8944            'endpoint': self.endpoint,
 8945            'healthy': self.healthy,
 8946            'id': self.id,
 8947            'name': self.name,
 8948            'port': self.port,
 8949            'port_override': self.port_override,
 8950            'region': self.region,
 8951            'role_arn': self.role_arn,
 8952            'role_external_id': self.role_external_id,
 8953            'secret_access_key': self.secret_access_key,
 8954            'secret_store_id': self.secret_store_id,
 8955            'tags': self.tags,
 8956        }
 8957
 8958    @classmethod
 8959    def from_dict(cls, d):
 8960        return cls(
 8961            access_key=d.get('access_key'),
 8962            bind_interface=d.get('bind_interface'),
 8963            egress_filter=d.get('egress_filter'),
 8964            endpoint=d.get('endpoint'),
 8965            healthy=d.get('healthy'),
 8966            id=d.get('id'),
 8967            name=d.get('name'),
 8968            port=d.get('port'),
 8969            port_override=d.get('port_override'),
 8970            region=d.get('region'),
 8971            role_arn=d.get('role_arn'),
 8972            role_external_id=d.get('role_external_id'),
 8973            secret_access_key=d.get('secret_access_key'),
 8974            secret_store_id=d.get('secret_store_id'),
 8975            tags=d.get('tags'),
 8976        )
 8977
 8978
 8979class NodeCreateResponse:
 8980    '''
 8981     NodeCreateResponse reports how the Nodes were created in the system.
 8982    '''
 8983    __slots__ = [
 8984        'meta',
 8985        'node',
 8986        'rate_limit',
 8987        'token',
 8988    ]
 8989
 8990    def __init__(
 8991        self,
 8992        meta=None,
 8993        node=None,
 8994        rate_limit=None,
 8995        token=None,
 8996    ):
 8997        self.meta = meta if meta is not None else None
 8998        '''
 8999         Reserved for future use.
 9000        '''
 9001        self.node = node if node is not None else None
 9002        '''
 9003         The created Node.
 9004        '''
 9005        self.rate_limit = rate_limit if rate_limit is not None else None
 9006        '''
 9007         Rate limit information.
 9008        '''
 9009        self.token = token if token is not None else ''
 9010        '''
 9011         The auth token generated for the Node. The Node will use this token to
 9012         authenticate with the strongDM API.
 9013        '''
 9014
 9015    def __repr__(self):
 9016        return '<sdm.NodeCreateResponse ' + \
 9017            'meta: ' + repr(self.meta) + ' ' +\
 9018            'node: ' + repr(self.node) + ' ' +\
 9019            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9020            'token: ' + repr(self.token) + ' ' +\
 9021            '>'
 9022
 9023    def to_dict(self):
 9024        return {
 9025            'meta': self.meta,
 9026            'node': self.node,
 9027            'rate_limit': self.rate_limit,
 9028            'token': self.token,
 9029        }
 9030
 9031    @classmethod
 9032    def from_dict(cls, d):
 9033        return cls(
 9034            meta=d.get('meta'),
 9035            node=d.get('node'),
 9036            rate_limit=d.get('rate_limit'),
 9037            token=d.get('token'),
 9038        )
 9039
 9040
 9041class NodeDeleteResponse:
 9042    '''
 9043     NodeDeleteResponse returns information about a Node that was deleted.
 9044    '''
 9045    __slots__ = [
 9046        'meta',
 9047        'rate_limit',
 9048    ]
 9049
 9050    def __init__(
 9051        self,
 9052        meta=None,
 9053        rate_limit=None,
 9054    ):
 9055        self.meta = meta if meta is not None else None
 9056        '''
 9057         Reserved for future use.
 9058        '''
 9059        self.rate_limit = rate_limit if rate_limit is not None else None
 9060        '''
 9061         Rate limit information.
 9062        '''
 9063
 9064    def __repr__(self):
 9065        return '<sdm.NodeDeleteResponse ' + \
 9066            'meta: ' + repr(self.meta) + ' ' +\
 9067            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9068            '>'
 9069
 9070    def to_dict(self):
 9071        return {
 9072            'meta': self.meta,
 9073            'rate_limit': self.rate_limit,
 9074        }
 9075
 9076    @classmethod
 9077    def from_dict(cls, d):
 9078        return cls(
 9079            meta=d.get('meta'),
 9080            rate_limit=d.get('rate_limit'),
 9081        )
 9082
 9083
 9084class NodeGetResponse:
 9085    '''
 9086     NodeGetResponse returns a requested Node.
 9087    '''
 9088    __slots__ = [
 9089        'meta',
 9090        'node',
 9091        'rate_limit',
 9092    ]
 9093
 9094    def __init__(
 9095        self,
 9096        meta=None,
 9097        node=None,
 9098        rate_limit=None,
 9099    ):
 9100        self.meta = meta if meta is not None else None
 9101        '''
 9102         Reserved for future use.
 9103        '''
 9104        self.node = node if node is not None else None
 9105        '''
 9106         The requested Node.
 9107        '''
 9108        self.rate_limit = rate_limit if rate_limit is not None else None
 9109        '''
 9110         Rate limit information.
 9111        '''
 9112
 9113    def __repr__(self):
 9114        return '<sdm.NodeGetResponse ' + \
 9115            'meta: ' + repr(self.meta) + ' ' +\
 9116            'node: ' + repr(self.node) + ' ' +\
 9117            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9118            '>'
 9119
 9120    def to_dict(self):
 9121        return {
 9122            'meta': self.meta,
 9123            'node': self.node,
 9124            'rate_limit': self.rate_limit,
 9125        }
 9126
 9127    @classmethod
 9128    def from_dict(cls, d):
 9129        return cls(
 9130            meta=d.get('meta'),
 9131            node=d.get('node'),
 9132            rate_limit=d.get('rate_limit'),
 9133        )
 9134
 9135
 9136class NodeUpdateResponse:
 9137    '''
 9138     NodeUpdateResponse returns the fields of a Node after it has been updated by
 9139     a NodeUpdateRequest.
 9140    '''
 9141    __slots__ = [
 9142        'meta',
 9143        'node',
 9144        'rate_limit',
 9145    ]
 9146
 9147    def __init__(
 9148        self,
 9149        meta=None,
 9150        node=None,
 9151        rate_limit=None,
 9152    ):
 9153        self.meta = meta if meta is not None else None
 9154        '''
 9155         Reserved for future use.
 9156        '''
 9157        self.node = node if node is not None else None
 9158        '''
 9159         The updated Node.
 9160        '''
 9161        self.rate_limit = rate_limit if rate_limit is not None else None
 9162        '''
 9163         Rate limit information.
 9164        '''
 9165
 9166    def __repr__(self):
 9167        return '<sdm.NodeUpdateResponse ' + \
 9168            'meta: ' + repr(self.meta) + ' ' +\
 9169            'node: ' + repr(self.node) + ' ' +\
 9170            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9171            '>'
 9172
 9173    def to_dict(self):
 9174        return {
 9175            'meta': self.meta,
 9176            'node': self.node,
 9177            'rate_limit': self.rate_limit,
 9178        }
 9179
 9180    @classmethod
 9181    def from_dict(cls, d):
 9182        return cls(
 9183            meta=d.get('meta'),
 9184            node=d.get('node'),
 9185            rate_limit=d.get('rate_limit'),
 9186        )
 9187
 9188
 9189class Oracle:
 9190    '''
 9191
 9192    '''
 9193    __slots__ = [
 9194        'bind_interface',
 9195        'database',
 9196        'egress_filter',
 9197        'healthy',
 9198        'hostname',
 9199        'id',
 9200        'name',
 9201        'password',
 9202        'port',
 9203        'port_override',
 9204        'secret_store_id',
 9205        'tags',
 9206        'tls_required',
 9207        'username',
 9208    ]
 9209
 9210    def __init__(
 9211        self,
 9212        bind_interface=None,
 9213        database=None,
 9214        egress_filter=None,
 9215        healthy=None,
 9216        hostname=None,
 9217        id=None,
 9218        name=None,
 9219        password=None,
 9220        port=None,
 9221        port_override=None,
 9222        secret_store_id=None,
 9223        tags=None,
 9224        tls_required=None,
 9225        username=None,
 9226    ):
 9227        self.bind_interface = bind_interface if bind_interface is not None else ''
 9228        '''
 9229         Bind interface
 9230        '''
 9231        self.database = database if database is not None else ''
 9232        '''
 9233
 9234        '''
 9235        self.egress_filter = egress_filter if egress_filter is not None else ''
 9236        '''
 9237         A filter applied to the routing logic to pin datasource to nodes.
 9238        '''
 9239        self.healthy = healthy if healthy is not None else False
 9240        '''
 9241         True if the datasource is reachable and the credentials are valid.
 9242        '''
 9243        self.hostname = hostname if hostname is not None else ''
 9244        '''
 9245
 9246        '''
 9247        self.id = id if id is not None else ''
 9248        '''
 9249         Unique identifier of the Resource.
 9250        '''
 9251        self.name = name if name is not None else ''
 9252        '''
 9253         Unique human-readable name of the Resource.
 9254        '''
 9255        self.password = password if password is not None else ''
 9256        '''
 9257
 9258        '''
 9259        self.port = port if port is not None else 0
 9260        '''
 9261
 9262        '''
 9263        self.port_override = port_override if port_override is not None else 0
 9264        '''
 9265
 9266        '''
 9267        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9268        '''
 9269         ID of the secret store containing credentials for this resource, if any.
 9270        '''
 9271        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9272        '''
 9273         Tags is a map of key, value pairs.
 9274        '''
 9275        self.tls_required = tls_required if tls_required is not None else False
 9276        '''
 9277
 9278        '''
 9279        self.username = username if username is not None else ''
 9280        '''
 9281
 9282        '''
 9283
 9284    def __repr__(self):
 9285        return '<sdm.Oracle ' + \
 9286            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9287            'database: ' + repr(self.database) + ' ' +\
 9288            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9289            'healthy: ' + repr(self.healthy) + ' ' +\
 9290            'hostname: ' + repr(self.hostname) + ' ' +\
 9291            'id: ' + repr(self.id) + ' ' +\
 9292            'name: ' + repr(self.name) + ' ' +\
 9293            'password: ' + repr(self.password) + ' ' +\
 9294            'port: ' + repr(self.port) + ' ' +\
 9295            'port_override: ' + repr(self.port_override) + ' ' +\
 9296            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9297            'tags: ' + repr(self.tags) + ' ' +\
 9298            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9299            'username: ' + repr(self.username) + ' ' +\
 9300            '>'
 9301
 9302    def to_dict(self):
 9303        return {
 9304            'bind_interface': self.bind_interface,
 9305            'database': self.database,
 9306            'egress_filter': self.egress_filter,
 9307            'healthy': self.healthy,
 9308            'hostname': self.hostname,
 9309            'id': self.id,
 9310            'name': self.name,
 9311            'password': self.password,
 9312            'port': self.port,
 9313            'port_override': self.port_override,
 9314            'secret_store_id': self.secret_store_id,
 9315            'tags': self.tags,
 9316            'tls_required': self.tls_required,
 9317            'username': self.username,
 9318        }
 9319
 9320    @classmethod
 9321    def from_dict(cls, d):
 9322        return cls(
 9323            bind_interface=d.get('bind_interface'),
 9324            database=d.get('database'),
 9325            egress_filter=d.get('egress_filter'),
 9326            healthy=d.get('healthy'),
 9327            hostname=d.get('hostname'),
 9328            id=d.get('id'),
 9329            name=d.get('name'),
 9330            password=d.get('password'),
 9331            port=d.get('port'),
 9332            port_override=d.get('port_override'),
 9333            secret_store_id=d.get('secret_store_id'),
 9334            tags=d.get('tags'),
 9335            tls_required=d.get('tls_required'),
 9336            username=d.get('username'),
 9337        )
 9338
 9339
 9340class Postgres:
 9341    '''
 9342
 9343    '''
 9344    __slots__ = [
 9345        'bind_interface',
 9346        'database',
 9347        'egress_filter',
 9348        'healthy',
 9349        'hostname',
 9350        'id',
 9351        'name',
 9352        'override_database',
 9353        'password',
 9354        'port',
 9355        'port_override',
 9356        'secret_store_id',
 9357        'tags',
 9358        'username',
 9359    ]
 9360
 9361    def __init__(
 9362        self,
 9363        bind_interface=None,
 9364        database=None,
 9365        egress_filter=None,
 9366        healthy=None,
 9367        hostname=None,
 9368        id=None,
 9369        name=None,
 9370        override_database=None,
 9371        password=None,
 9372        port=None,
 9373        port_override=None,
 9374        secret_store_id=None,
 9375        tags=None,
 9376        username=None,
 9377    ):
 9378        self.bind_interface = bind_interface if bind_interface is not None else ''
 9379        '''
 9380         Bind interface
 9381        '''
 9382        self.database = database if database is not None else ''
 9383        '''
 9384
 9385        '''
 9386        self.egress_filter = egress_filter if egress_filter is not None else ''
 9387        '''
 9388         A filter applied to the routing logic to pin datasource to nodes.
 9389        '''
 9390        self.healthy = healthy if healthy is not None else False
 9391        '''
 9392         True if the datasource is reachable and the credentials are valid.
 9393        '''
 9394        self.hostname = hostname if hostname is not None else ''
 9395        '''
 9396
 9397        '''
 9398        self.id = id if id is not None else ''
 9399        '''
 9400         Unique identifier of the Resource.
 9401        '''
 9402        self.name = name if name is not None else ''
 9403        '''
 9404         Unique human-readable name of the Resource.
 9405        '''
 9406        self.override_database = override_database if override_database is not None else False
 9407        '''
 9408
 9409        '''
 9410        self.password = password if password is not None else ''
 9411        '''
 9412
 9413        '''
 9414        self.port = port if port is not None else 0
 9415        '''
 9416
 9417        '''
 9418        self.port_override = port_override if port_override is not None else 0
 9419        '''
 9420
 9421        '''
 9422        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9423        '''
 9424         ID of the secret store containing credentials for this resource, if any.
 9425        '''
 9426        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9427        '''
 9428         Tags is a map of key, value pairs.
 9429        '''
 9430        self.username = username if username is not None else ''
 9431        '''
 9432
 9433        '''
 9434
 9435    def __repr__(self):
 9436        return '<sdm.Postgres ' + \
 9437            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9438            'database: ' + repr(self.database) + ' ' +\
 9439            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9440            'healthy: ' + repr(self.healthy) + ' ' +\
 9441            'hostname: ' + repr(self.hostname) + ' ' +\
 9442            'id: ' + repr(self.id) + ' ' +\
 9443            'name: ' + repr(self.name) + ' ' +\
 9444            'override_database: ' + repr(self.override_database) + ' ' +\
 9445            'password: ' + repr(self.password) + ' ' +\
 9446            'port: ' + repr(self.port) + ' ' +\
 9447            'port_override: ' + repr(self.port_override) + ' ' +\
 9448            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9449            'tags: ' + repr(self.tags) + ' ' +\
 9450            'username: ' + repr(self.username) + ' ' +\
 9451            '>'
 9452
 9453    def to_dict(self):
 9454        return {
 9455            'bind_interface': self.bind_interface,
 9456            'database': self.database,
 9457            'egress_filter': self.egress_filter,
 9458            'healthy': self.healthy,
 9459            'hostname': self.hostname,
 9460            'id': self.id,
 9461            'name': self.name,
 9462            'override_database': self.override_database,
 9463            'password': self.password,
 9464            'port': self.port,
 9465            'port_override': self.port_override,
 9466            'secret_store_id': self.secret_store_id,
 9467            'tags': self.tags,
 9468            'username': self.username,
 9469        }
 9470
 9471    @classmethod
 9472    def from_dict(cls, d):
 9473        return cls(
 9474            bind_interface=d.get('bind_interface'),
 9475            database=d.get('database'),
 9476            egress_filter=d.get('egress_filter'),
 9477            healthy=d.get('healthy'),
 9478            hostname=d.get('hostname'),
 9479            id=d.get('id'),
 9480            name=d.get('name'),
 9481            override_database=d.get('override_database'),
 9482            password=d.get('password'),
 9483            port=d.get('port'),
 9484            port_override=d.get('port_override'),
 9485            secret_store_id=d.get('secret_store_id'),
 9486            tags=d.get('tags'),
 9487            username=d.get('username'),
 9488        )
 9489
 9490
 9491class Presto:
 9492    '''
 9493
 9494    '''
 9495    __slots__ = [
 9496        'bind_interface',
 9497        'database',
 9498        'egress_filter',
 9499        'healthy',
 9500        'hostname',
 9501        'id',
 9502        'name',
 9503        'password',
 9504        'port',
 9505        'port_override',
 9506        'secret_store_id',
 9507        'tags',
 9508        'tls_required',
 9509        'username',
 9510    ]
 9511
 9512    def __init__(
 9513        self,
 9514        bind_interface=None,
 9515        database=None,
 9516        egress_filter=None,
 9517        healthy=None,
 9518        hostname=None,
 9519        id=None,
 9520        name=None,
 9521        password=None,
 9522        port=None,
 9523        port_override=None,
 9524        secret_store_id=None,
 9525        tags=None,
 9526        tls_required=None,
 9527        username=None,
 9528    ):
 9529        self.bind_interface = bind_interface if bind_interface is not None else ''
 9530        '''
 9531         Bind interface
 9532        '''
 9533        self.database = database if database is not None else ''
 9534        '''
 9535
 9536        '''
 9537        self.egress_filter = egress_filter if egress_filter is not None else ''
 9538        '''
 9539         A filter applied to the routing logic to pin datasource to nodes.
 9540        '''
 9541        self.healthy = healthy if healthy is not None else False
 9542        '''
 9543         True if the datasource is reachable and the credentials are valid.
 9544        '''
 9545        self.hostname = hostname if hostname is not None else ''
 9546        '''
 9547
 9548        '''
 9549        self.id = id if id is not None else ''
 9550        '''
 9551         Unique identifier of the Resource.
 9552        '''
 9553        self.name = name if name is not None else ''
 9554        '''
 9555         Unique human-readable name of the Resource.
 9556        '''
 9557        self.password = password if password is not None else ''
 9558        '''
 9559
 9560        '''
 9561        self.port = port if port is not None else 0
 9562        '''
 9563
 9564        '''
 9565        self.port_override = port_override if port_override is not None else 0
 9566        '''
 9567
 9568        '''
 9569        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9570        '''
 9571         ID of the secret store containing credentials for this resource, if any.
 9572        '''
 9573        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9574        '''
 9575         Tags is a map of key, value pairs.
 9576        '''
 9577        self.tls_required = tls_required if tls_required is not None else False
 9578        '''
 9579
 9580        '''
 9581        self.username = username if username is not None else ''
 9582        '''
 9583
 9584        '''
 9585
 9586    def __repr__(self):
 9587        return '<sdm.Presto ' + \
 9588            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9589            'database: ' + repr(self.database) + ' ' +\
 9590            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9591            'healthy: ' + repr(self.healthy) + ' ' +\
 9592            'hostname: ' + repr(self.hostname) + ' ' +\
 9593            'id: ' + repr(self.id) + ' ' +\
 9594            'name: ' + repr(self.name) + ' ' +\
 9595            'password: ' + repr(self.password) + ' ' +\
 9596            'port: ' + repr(self.port) + ' ' +\
 9597            'port_override: ' + repr(self.port_override) + ' ' +\
 9598            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9599            'tags: ' + repr(self.tags) + ' ' +\
 9600            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9601            'username: ' + repr(self.username) + ' ' +\
 9602            '>'
 9603
 9604    def to_dict(self):
 9605        return {
 9606            'bind_interface': self.bind_interface,
 9607            'database': self.database,
 9608            'egress_filter': self.egress_filter,
 9609            'healthy': self.healthy,
 9610            'hostname': self.hostname,
 9611            'id': self.id,
 9612            'name': self.name,
 9613            'password': self.password,
 9614            'port': self.port,
 9615            'port_override': self.port_override,
 9616            'secret_store_id': self.secret_store_id,
 9617            'tags': self.tags,
 9618            'tls_required': self.tls_required,
 9619            'username': self.username,
 9620        }
 9621
 9622    @classmethod
 9623    def from_dict(cls, d):
 9624        return cls(
 9625            bind_interface=d.get('bind_interface'),
 9626            database=d.get('database'),
 9627            egress_filter=d.get('egress_filter'),
 9628            healthy=d.get('healthy'),
 9629            hostname=d.get('hostname'),
 9630            id=d.get('id'),
 9631            name=d.get('name'),
 9632            password=d.get('password'),
 9633            port=d.get('port'),
 9634            port_override=d.get('port_override'),
 9635            secret_store_id=d.get('secret_store_id'),
 9636            tags=d.get('tags'),
 9637            tls_required=d.get('tls_required'),
 9638            username=d.get('username'),
 9639        )
 9640
 9641
 9642class RDP:
 9643    '''
 9644
 9645    '''
 9646    __slots__ = [
 9647        'bind_interface',
 9648        'downgrade_nla_connections',
 9649        'egress_filter',
 9650        'healthy',
 9651        'hostname',
 9652        'id',
 9653        'name',
 9654        'password',
 9655        'port',
 9656        'port_override',
 9657        'secret_store_id',
 9658        'tags',
 9659        'username',
 9660    ]
 9661
 9662    def __init__(
 9663        self,
 9664        bind_interface=None,
 9665        downgrade_nla_connections=None,
 9666        egress_filter=None,
 9667        healthy=None,
 9668        hostname=None,
 9669        id=None,
 9670        name=None,
 9671        password=None,
 9672        port=None,
 9673        port_override=None,
 9674        secret_store_id=None,
 9675        tags=None,
 9676        username=None,
 9677    ):
 9678        self.bind_interface = bind_interface if bind_interface is not None else ''
 9679        '''
 9680         Bind interface
 9681        '''
 9682        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
 9683        '''
 9684
 9685        '''
 9686        self.egress_filter = egress_filter if egress_filter is not None else ''
 9687        '''
 9688         A filter applied to the routing logic to pin datasource to nodes.
 9689        '''
 9690        self.healthy = healthy if healthy is not None else False
 9691        '''
 9692         True if the datasource is reachable and the credentials are valid.
 9693        '''
 9694        self.hostname = hostname if hostname is not None else ''
 9695        '''
 9696
 9697        '''
 9698        self.id = id if id is not None else ''
 9699        '''
 9700         Unique identifier of the Resource.
 9701        '''
 9702        self.name = name if name is not None else ''
 9703        '''
 9704         Unique human-readable name of the Resource.
 9705        '''
 9706        self.password = password if password is not None else ''
 9707        '''
 9708
 9709        '''
 9710        self.port = port if port is not None else 0
 9711        '''
 9712
 9713        '''
 9714        self.port_override = port_override if port_override is not None else 0
 9715        '''
 9716
 9717        '''
 9718        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9719        '''
 9720         ID of the secret store containing credentials for this resource, if any.
 9721        '''
 9722        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9723        '''
 9724         Tags is a map of key, value pairs.
 9725        '''
 9726        self.username = username if username is not None else ''
 9727        '''
 9728
 9729        '''
 9730
 9731    def __repr__(self):
 9732        return '<sdm.RDP ' + \
 9733            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9734            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
 9735            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9736            'healthy: ' + repr(self.healthy) + ' ' +\
 9737            'hostname: ' + repr(self.hostname) + ' ' +\
 9738            'id: ' + repr(self.id) + ' ' +\
 9739            'name: ' + repr(self.name) + ' ' +\
 9740            'password: ' + repr(self.password) + ' ' +\
 9741            'port: ' + repr(self.port) + ' ' +\
 9742            'port_override: ' + repr(self.port_override) + ' ' +\
 9743            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9744            'tags: ' + repr(self.tags) + ' ' +\
 9745            'username: ' + repr(self.username) + ' ' +\
 9746            '>'
 9747
 9748    def to_dict(self):
 9749        return {
 9750            'bind_interface': self.bind_interface,
 9751            'downgrade_nla_connections': self.downgrade_nla_connections,
 9752            'egress_filter': self.egress_filter,
 9753            'healthy': self.healthy,
 9754            'hostname': self.hostname,
 9755            'id': self.id,
 9756            'name': self.name,
 9757            'password': self.password,
 9758            'port': self.port,
 9759            'port_override': self.port_override,
 9760            'secret_store_id': self.secret_store_id,
 9761            'tags': self.tags,
 9762            'username': self.username,
 9763        }
 9764
 9765    @classmethod
 9766    def from_dict(cls, d):
 9767        return cls(
 9768            bind_interface=d.get('bind_interface'),
 9769            downgrade_nla_connections=d.get('downgrade_nla_connections'),
 9770            egress_filter=d.get('egress_filter'),
 9771            healthy=d.get('healthy'),
 9772            hostname=d.get('hostname'),
 9773            id=d.get('id'),
 9774            name=d.get('name'),
 9775            password=d.get('password'),
 9776            port=d.get('port'),
 9777            port_override=d.get('port_override'),
 9778            secret_store_id=d.get('secret_store_id'),
 9779            tags=d.get('tags'),
 9780            username=d.get('username'),
 9781        )
 9782
 9783
 9784class RabbitMQAMQP091:
 9785    '''
 9786
 9787    '''
 9788    __slots__ = [
 9789        'bind_interface',
 9790        'egress_filter',
 9791        'healthy',
 9792        'hostname',
 9793        'id',
 9794        'name',
 9795        'password',
 9796        'port',
 9797        'port_override',
 9798        'secret_store_id',
 9799        'tags',
 9800        'tls_required',
 9801        'username',
 9802    ]
 9803
 9804    def __init__(
 9805        self,
 9806        bind_interface=None,
 9807        egress_filter=None,
 9808        healthy=None,
 9809        hostname=None,
 9810        id=None,
 9811        name=None,
 9812        password=None,
 9813        port=None,
 9814        port_override=None,
 9815        secret_store_id=None,
 9816        tags=None,
 9817        tls_required=None,
 9818        username=None,
 9819    ):
 9820        self.bind_interface = bind_interface if bind_interface is not None else ''
 9821        '''
 9822         Bind interface
 9823        '''
 9824        self.egress_filter = egress_filter if egress_filter is not None else ''
 9825        '''
 9826         A filter applied to the routing logic to pin datasource to nodes.
 9827        '''
 9828        self.healthy = healthy if healthy is not None else False
 9829        '''
 9830         True if the datasource is reachable and the credentials are valid.
 9831        '''
 9832        self.hostname = hostname if hostname is not None else ''
 9833        '''
 9834
 9835        '''
 9836        self.id = id if id is not None else ''
 9837        '''
 9838         Unique identifier of the Resource.
 9839        '''
 9840        self.name = name if name is not None else ''
 9841        '''
 9842         Unique human-readable name of the Resource.
 9843        '''
 9844        self.password = password if password is not None else ''
 9845        '''
 9846
 9847        '''
 9848        self.port = port if port is not None else 0
 9849        '''
 9850
 9851        '''
 9852        self.port_override = port_override if port_override is not None else 0
 9853        '''
 9854
 9855        '''
 9856        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9857        '''
 9858         ID of the secret store containing credentials for this resource, if any.
 9859        '''
 9860        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9861        '''
 9862         Tags is a map of key, value pairs.
 9863        '''
 9864        self.tls_required = tls_required if tls_required is not None else False
 9865        '''
 9866
 9867        '''
 9868        self.username = username if username is not None else ''
 9869        '''
 9870
 9871        '''
 9872
 9873    def __repr__(self):
 9874        return '<sdm.RabbitMQAMQP091 ' + \
 9875            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9876            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9877            'healthy: ' + repr(self.healthy) + ' ' +\
 9878            'hostname: ' + repr(self.hostname) + ' ' +\
 9879            'id: ' + repr(self.id) + ' ' +\
 9880            'name: ' + repr(self.name) + ' ' +\
 9881            'password: ' + repr(self.password) + ' ' +\
 9882            'port: ' + repr(self.port) + ' ' +\
 9883            'port_override: ' + repr(self.port_override) + ' ' +\
 9884            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9885            'tags: ' + repr(self.tags) + ' ' +\
 9886            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9887            'username: ' + repr(self.username) + ' ' +\
 9888            '>'
 9889
 9890    def to_dict(self):
 9891        return {
 9892            'bind_interface': self.bind_interface,
 9893            'egress_filter': self.egress_filter,
 9894            'healthy': self.healthy,
 9895            'hostname': self.hostname,
 9896            'id': self.id,
 9897            'name': self.name,
 9898            'password': self.password,
 9899            'port': self.port,
 9900            'port_override': self.port_override,
 9901            'secret_store_id': self.secret_store_id,
 9902            'tags': self.tags,
 9903            'tls_required': self.tls_required,
 9904            'username': self.username,
 9905        }
 9906
 9907    @classmethod
 9908    def from_dict(cls, d):
 9909        return cls(
 9910            bind_interface=d.get('bind_interface'),
 9911            egress_filter=d.get('egress_filter'),
 9912            healthy=d.get('healthy'),
 9913            hostname=d.get('hostname'),
 9914            id=d.get('id'),
 9915            name=d.get('name'),
 9916            password=d.get('password'),
 9917            port=d.get('port'),
 9918            port_override=d.get('port_override'),
 9919            secret_store_id=d.get('secret_store_id'),
 9920            tags=d.get('tags'),
 9921            tls_required=d.get('tls_required'),
 9922            username=d.get('username'),
 9923        )
 9924
 9925
 9926class RateLimitMetadata:
 9927    '''
 9928     RateLimitMetadata contains information about remaining requests avaialable
 9929     to the user over some timeframe.
 9930    '''
 9931    __slots__ = [
 9932        'bucket',
 9933        'limit',
 9934        'remaining',
 9935        'reset_at',
 9936    ]
 9937
 9938    def __init__(
 9939        self,
 9940        bucket=None,
 9941        limit=None,
 9942        remaining=None,
 9943        reset_at=None,
 9944    ):
 9945        self.bucket = bucket if bucket is not None else ''
 9946        '''
 9947         The bucket this user/token is associated with, which may be shared between
 9948         multiple users/tokens.
 9949        '''
 9950        self.limit = limit if limit is not None else 0
 9951        '''
 9952         How many total requests the user/token is authorized to make before being
 9953         rate limited.
 9954        '''
 9955        self.remaining = remaining if remaining is not None else 0
 9956        '''
 9957         How many remaining requests out of the limit are still avaialable.
 9958        '''
 9959        self.reset_at = reset_at if reset_at is not None else None
 9960        '''
 9961         The time when remaining will be reset to limit.
 9962        '''
 9963
 9964    def __repr__(self):
 9965        return '<sdm.RateLimitMetadata ' + \
 9966            'bucket: ' + repr(self.bucket) + ' ' +\
 9967            'limit: ' + repr(self.limit) + ' ' +\
 9968            'remaining: ' + repr(self.remaining) + ' ' +\
 9969            'reset_at: ' + repr(self.reset_at) + ' ' +\
 9970            '>'
 9971
 9972    def to_dict(self):
 9973        return {
 9974            'bucket': self.bucket,
 9975            'limit': self.limit,
 9976            'remaining': self.remaining,
 9977            'reset_at': self.reset_at,
 9978        }
 9979
 9980    @classmethod
 9981    def from_dict(cls, d):
 9982        return cls(
 9983            bucket=d.get('bucket'),
 9984            limit=d.get('limit'),
 9985            remaining=d.get('remaining'),
 9986            reset_at=d.get('reset_at'),
 9987        )
 9988
 9989
 9990class RawTCP:
 9991    '''
 9992
 9993    '''
 9994    __slots__ = [
 9995        'bind_interface',
 9996        'egress_filter',
 9997        'healthy',
 9998        'hostname',
 9999        'id',
10000        'name',
10001        'port',
10002        'port_override',
10003        'secret_store_id',
10004        'tags',
10005    ]
10006
10007    def __init__(
10008        self,
10009        bind_interface=None,
10010        egress_filter=None,
10011        healthy=None,
10012        hostname=None,
10013        id=None,
10014        name=None,
10015        port=None,
10016        port_override=None,
10017        secret_store_id=None,
10018        tags=None,
10019    ):
10020        self.bind_interface = bind_interface if bind_interface is not None else ''
10021        '''
10022         Bind interface
10023        '''
10024        self.egress_filter = egress_filter if egress_filter is not None else ''
10025        '''
10026         A filter applied to the routing logic to pin datasource to nodes.
10027        '''
10028        self.healthy = healthy if healthy is not None else False
10029        '''
10030         True if the datasource is reachable and the credentials are valid.
10031        '''
10032        self.hostname = hostname if hostname is not None else ''
10033        '''
10034
10035        '''
10036        self.id = id if id is not None else ''
10037        '''
10038         Unique identifier of the Resource.
10039        '''
10040        self.name = name if name is not None else ''
10041        '''
10042         Unique human-readable name of the Resource.
10043        '''
10044        self.port = port if port is not None else 0
10045        '''
10046
10047        '''
10048        self.port_override = port_override if port_override is not None else 0
10049        '''
10050
10051        '''
10052        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10053        '''
10054         ID of the secret store containing credentials for this resource, if any.
10055        '''
10056        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10057        '''
10058         Tags is a map of key, value pairs.
10059        '''
10060
10061    def __repr__(self):
10062        return '<sdm.RawTCP ' + \
10063            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10064            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10065            'healthy: ' + repr(self.healthy) + ' ' +\
10066            'hostname: ' + repr(self.hostname) + ' ' +\
10067            'id: ' + repr(self.id) + ' ' +\
10068            'name: ' + repr(self.name) + ' ' +\
10069            'port: ' + repr(self.port) + ' ' +\
10070            'port_override: ' + repr(self.port_override) + ' ' +\
10071            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10072            'tags: ' + repr(self.tags) + ' ' +\
10073            '>'
10074
10075    def to_dict(self):
10076        return {
10077            'bind_interface': self.bind_interface,
10078            'egress_filter': self.egress_filter,
10079            'healthy': self.healthy,
10080            'hostname': self.hostname,
10081            'id': self.id,
10082            'name': self.name,
10083            'port': self.port,
10084            'port_override': self.port_override,
10085            'secret_store_id': self.secret_store_id,
10086            'tags': self.tags,
10087        }
10088
10089    @classmethod
10090    def from_dict(cls, d):
10091        return cls(
10092            bind_interface=d.get('bind_interface'),
10093            egress_filter=d.get('egress_filter'),
10094            healthy=d.get('healthy'),
10095            hostname=d.get('hostname'),
10096            id=d.get('id'),
10097            name=d.get('name'),
10098            port=d.get('port'),
10099            port_override=d.get('port_override'),
10100            secret_store_id=d.get('secret_store_id'),
10101            tags=d.get('tags'),
10102        )
10103
10104
10105class Redis:
10106    '''
10107
10108    '''
10109    __slots__ = [
10110        'bind_interface',
10111        'egress_filter',
10112        'healthy',
10113        'hostname',
10114        'id',
10115        'name',
10116        'password',
10117        'port',
10118        'port_override',
10119        'secret_store_id',
10120        'tags',
10121    ]
10122
10123    def __init__(
10124        self,
10125        bind_interface=None,
10126        egress_filter=None,
10127        healthy=None,
10128        hostname=None,
10129        id=None,
10130        name=None,
10131        password=None,
10132        port=None,
10133        port_override=None,
10134        secret_store_id=None,
10135        tags=None,
10136    ):
10137        self.bind_interface = bind_interface if bind_interface is not None else ''
10138        '''
10139         Bind interface
10140        '''
10141        self.egress_filter = egress_filter if egress_filter is not None else ''
10142        '''
10143         A filter applied to the routing logic to pin datasource to nodes.
10144        '''
10145        self.healthy = healthy if healthy is not None else False
10146        '''
10147         True if the datasource is reachable and the credentials are valid.
10148        '''
10149        self.hostname = hostname if hostname is not None else ''
10150        '''
10151
10152        '''
10153        self.id = id if id is not None else ''
10154        '''
10155         Unique identifier of the Resource.
10156        '''
10157        self.name = name if name is not None else ''
10158        '''
10159         Unique human-readable name of the Resource.
10160        '''
10161        self.password = password if password is not None else ''
10162        '''
10163
10164        '''
10165        self.port = port if port is not None else 0
10166        '''
10167
10168        '''
10169        self.port_override = port_override if port_override is not None else 0
10170        '''
10171
10172        '''
10173        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10174        '''
10175         ID of the secret store containing credentials for this resource, if any.
10176        '''
10177        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10178        '''
10179         Tags is a map of key, value pairs.
10180        '''
10181
10182    def __repr__(self):
10183        return '<sdm.Redis ' + \
10184            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10185            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10186            'healthy: ' + repr(self.healthy) + ' ' +\
10187            'hostname: ' + repr(self.hostname) + ' ' +\
10188            'id: ' + repr(self.id) + ' ' +\
10189            'name: ' + repr(self.name) + ' ' +\
10190            'password: ' + repr(self.password) + ' ' +\
10191            'port: ' + repr(self.port) + ' ' +\
10192            'port_override: ' + repr(self.port_override) + ' ' +\
10193            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10194            'tags: ' + repr(self.tags) + ' ' +\
10195            '>'
10196
10197    def to_dict(self):
10198        return {
10199            'bind_interface': self.bind_interface,
10200            'egress_filter': self.egress_filter,
10201            'healthy': self.healthy,
10202            'hostname': self.hostname,
10203            'id': self.id,
10204            'name': self.name,
10205            'password': self.password,
10206            'port': self.port,
10207            'port_override': self.port_override,
10208            'secret_store_id': self.secret_store_id,
10209            'tags': self.tags,
10210        }
10211
10212    @classmethod
10213    def from_dict(cls, d):
10214        return cls(
10215            bind_interface=d.get('bind_interface'),
10216            egress_filter=d.get('egress_filter'),
10217            healthy=d.get('healthy'),
10218            hostname=d.get('hostname'),
10219            id=d.get('id'),
10220            name=d.get('name'),
10221            password=d.get('password'),
10222            port=d.get('port'),
10223            port_override=d.get('port_override'),
10224            secret_store_id=d.get('secret_store_id'),
10225            tags=d.get('tags'),
10226        )
10227
10228
10229class Redshift:
10230    '''
10231
10232    '''
10233    __slots__ = [
10234        'bind_interface',
10235        'database',
10236        'egress_filter',
10237        'healthy',
10238        'hostname',
10239        'id',
10240        'name',
10241        'override_database',
10242        'password',
10243        'port',
10244        'port_override',
10245        'secret_store_id',
10246        'tags',
10247        'username',
10248    ]
10249
10250    def __init__(
10251        self,
10252        bind_interface=None,
10253        database=None,
10254        egress_filter=None,
10255        healthy=None,
10256        hostname=None,
10257        id=None,
10258        name=None,
10259        override_database=None,
10260        password=None,
10261        port=None,
10262        port_override=None,
10263        secret_store_id=None,
10264        tags=None,
10265        username=None,
10266    ):
10267        self.bind_interface = bind_interface if bind_interface is not None else ''
10268        '''
10269         Bind interface
10270        '''
10271        self.database = database if database is not None else ''
10272        '''
10273
10274        '''
10275        self.egress_filter = egress_filter if egress_filter is not None else ''
10276        '''
10277         A filter applied to the routing logic to pin datasource to nodes.
10278        '''
10279        self.healthy = healthy if healthy is not None else False
10280        '''
10281         True if the datasource is reachable and the credentials are valid.
10282        '''
10283        self.hostname = hostname if hostname is not None else ''
10284        '''
10285
10286        '''
10287        self.id = id if id is not None else ''
10288        '''
10289         Unique identifier of the Resource.
10290        '''
10291        self.name = name if name is not None else ''
10292        '''
10293         Unique human-readable name of the Resource.
10294        '''
10295        self.override_database = override_database if override_database is not None else False
10296        '''
10297
10298        '''
10299        self.password = password if password is not None else ''
10300        '''
10301
10302        '''
10303        self.port = port if port is not None else 0
10304        '''
10305
10306        '''
10307        self.port_override = port_override if port_override is not None else 0
10308        '''
10309
10310        '''
10311        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10312        '''
10313         ID of the secret store containing credentials for this resource, if any.
10314        '''
10315        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10316        '''
10317         Tags is a map of key, value pairs.
10318        '''
10319        self.username = username if username is not None else ''
10320        '''
10321
10322        '''
10323
10324    def __repr__(self):
10325        return '<sdm.Redshift ' + \
10326            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10327            'database: ' + repr(self.database) + ' ' +\
10328            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10329            'healthy: ' + repr(self.healthy) + ' ' +\
10330            'hostname: ' + repr(self.hostname) + ' ' +\
10331            'id: ' + repr(self.id) + ' ' +\
10332            'name: ' + repr(self.name) + ' ' +\
10333            'override_database: ' + repr(self.override_database) + ' ' +\
10334            'password: ' + repr(self.password) + ' ' +\
10335            'port: ' + repr(self.port) + ' ' +\
10336            'port_override: ' + repr(self.port_override) + ' ' +\
10337            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10338            'tags: ' + repr(self.tags) + ' ' +\
10339            'username: ' + repr(self.username) + ' ' +\
10340            '>'
10341
10342    def to_dict(self):
10343        return {
10344            'bind_interface': self.bind_interface,
10345            'database': self.database,
10346            'egress_filter': self.egress_filter,
10347            'healthy': self.healthy,
10348            'hostname': self.hostname,
10349            'id': self.id,
10350            'name': self.name,
10351            'override_database': self.override_database,
10352            'password': self.password,
10353            'port': self.port,
10354            'port_override': self.port_override,
10355            'secret_store_id': self.secret_store_id,
10356            'tags': self.tags,
10357            'username': self.username,
10358        }
10359
10360    @classmethod
10361    def from_dict(cls, d):
10362        return cls(
10363            bind_interface=d.get('bind_interface'),
10364            database=d.get('database'),
10365            egress_filter=d.get('egress_filter'),
10366            healthy=d.get('healthy'),
10367            hostname=d.get('hostname'),
10368            id=d.get('id'),
10369            name=d.get('name'),
10370            override_database=d.get('override_database'),
10371            password=d.get('password'),
10372            port=d.get('port'),
10373            port_override=d.get('port_override'),
10374            secret_store_id=d.get('secret_store_id'),
10375            tags=d.get('tags'),
10376            username=d.get('username'),
10377        )
10378
10379
10380class Relay:
10381    '''
10382     Relay represents a StrongDM CLI installation running in relay mode.
10383    '''
10384    __slots__ = [
10385        'gateway_filter',
10386        'id',
10387        'name',
10388        'state',
10389        'tags',
10390    ]
10391
10392    def __init__(
10393        self,
10394        gateway_filter=None,
10395        id=None,
10396        name=None,
10397        state=None,
10398        tags=None,
10399    ):
10400        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
10401        '''
10402         GatewayFilter can be used to restrict the peering between relays and
10403         gateways.
10404        '''
10405        self.id = id if id is not None else ''
10406        '''
10407         Unique identifier of the Relay.
10408        '''
10409        self.name = name if name is not None else ''
10410        '''
10411         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
10412        '''
10413        self.state = state if state is not None else ''
10414        '''
10415         The current state of the relay. One of: "new", "verifying_restart",
10416         "awaiting_restart", "restarting", "started", "stopped", "dead",
10417         "unknown".
10418        '''
10419        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10420        '''
10421         Tags is a map of key, value pairs.
10422        '''
10423
10424    def __repr__(self):
10425        return '<sdm.Relay ' + \
10426            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
10427            'id: ' + repr(self.id) + ' ' +\
10428            'name: ' + repr(self.name) + ' ' +\
10429            'state: ' + repr(self.state) + ' ' +\
10430            'tags: ' + repr(self.tags) + ' ' +\
10431            '>'
10432
10433    def to_dict(self):
10434        return {
10435            'gateway_filter': self.gateway_filter,
10436            'id': self.id,
10437            'name': self.name,
10438            'state': self.state,
10439            'tags': self.tags,
10440        }
10441
10442    @classmethod
10443    def from_dict(cls, d):
10444        return cls(
10445            gateway_filter=d.get('gateway_filter'),
10446            id=d.get('id'),
10447            name=d.get('name'),
10448            state=d.get('state'),
10449            tags=d.get('tags'),
10450        )
10451
10452
10453class RemoteIdentity:
10454    '''
10455     RemoteIdentities define the username to be used for a specific account
10456     when connecting to a remote resource using that group.
10457    '''
10458    __slots__ = [
10459        'account_id',
10460        'id',
10461        'remote_identity_group_id',
10462        'username',
10463    ]
10464
10465    def __init__(
10466        self,
10467        account_id=None,
10468        id=None,
10469        remote_identity_group_id=None,
10470        username=None,
10471    ):
10472        self.account_id = account_id if account_id is not None else ''
10473        '''
10474         The account for this remote identity.
10475        '''
10476        self.id = id if id is not None else ''
10477        '''
10478         Unique identifier of the RemoteIdentity.
10479        '''
10480        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10481        '''
10482         The remote identity group.
10483        '''
10484        self.username = username if username is not None else ''
10485        '''
10486         The username to be used as the remote identity for this account.
10487        '''
10488
10489    def __repr__(self):
10490        return '<sdm.RemoteIdentity ' + \
10491            'account_id: ' + repr(self.account_id) + ' ' +\
10492            'id: ' + repr(self.id) + ' ' +\
10493            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10494            'username: ' + repr(self.username) + ' ' +\
10495            '>'
10496
10497    def to_dict(self):
10498        return {
10499            'account_id': self.account_id,
10500            'id': self.id,
10501            'remote_identity_group_id': self.remote_identity_group_id,
10502            'username': self.username,
10503        }
10504
10505    @classmethod
10506    def from_dict(cls, d):
10507        return cls(
10508            account_id=d.get('account_id'),
10509            id=d.get('id'),
10510            remote_identity_group_id=d.get('remote_identity_group_id'),
10511            username=d.get('username'),
10512        )
10513
10514
10515class RemoteIdentityCreateResponse:
10516    '''
10517     RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
10518    '''
10519    __slots__ = [
10520        'meta',
10521        'rate_limit',
10522        'remote_identity',
10523    ]
10524
10525    def __init__(
10526        self,
10527        meta=None,
10528        rate_limit=None,
10529        remote_identity=None,
10530    ):
10531        self.meta = meta if meta is not None else None
10532        '''
10533         Reserved for future use.
10534        '''
10535        self.rate_limit = rate_limit if rate_limit is not None else None
10536        '''
10537         Rate limit information.
10538        '''
10539        self.remote_identity = remote_identity if remote_identity is not None else None
10540        '''
10541         The created RemoteIdentity.
10542        '''
10543
10544    def __repr__(self):
10545        return '<sdm.RemoteIdentityCreateResponse ' + \
10546            'meta: ' + repr(self.meta) + ' ' +\
10547            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10548            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10549            '>'
10550
10551    def to_dict(self):
10552        return {
10553            'meta': self.meta,
10554            'rate_limit': self.rate_limit,
10555            'remote_identity': self.remote_identity,
10556        }
10557
10558    @classmethod
10559    def from_dict(cls, d):
10560        return cls(
10561            meta=d.get('meta'),
10562            rate_limit=d.get('rate_limit'),
10563            remote_identity=d.get('remote_identity'),
10564        )
10565
10566
10567class RemoteIdentityDeleteResponse:
10568    '''
10569     RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
10570    '''
10571    __slots__ = [
10572        'meta',
10573        'rate_limit',
10574    ]
10575
10576    def __init__(
10577        self,
10578        meta=None,
10579        rate_limit=None,
10580    ):
10581        self.meta = meta if meta is not None else None
10582        '''
10583         Reserved for future use.
10584        '''
10585        self.rate_limit = rate_limit if rate_limit is not None else None
10586        '''
10587         Rate limit information.
10588        '''
10589
10590    def __repr__(self):
10591        return '<sdm.RemoteIdentityDeleteResponse ' + \
10592            'meta: ' + repr(self.meta) + ' ' +\
10593            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10594            '>'
10595
10596    def to_dict(self):
10597        return {
10598            'meta': self.meta,
10599            'rate_limit': self.rate_limit,
10600        }
10601
10602    @classmethod
10603    def from_dict(cls, d):
10604        return cls(
10605            meta=d.get('meta'),
10606            rate_limit=d.get('rate_limit'),
10607        )
10608
10609
10610class RemoteIdentityGetResponse:
10611    '''
10612     RemoteIdentityGetResponse returns a requested RemoteIdentity.
10613    '''
10614    __slots__ = [
10615        'meta',
10616        'rate_limit',
10617        'remote_identity',
10618    ]
10619
10620    def __init__(
10621        self,
10622        meta=None,
10623        rate_limit=None,
10624        remote_identity=None,
10625    ):
10626        self.meta = meta if meta is not None else None
10627        '''
10628         Reserved for future use.
10629        '''
10630        self.rate_limit = rate_limit if rate_limit is not None else None
10631        '''
10632         Rate limit information.
10633        '''
10634        self.remote_identity = remote_identity if remote_identity is not None else None
10635        '''
10636         The requested RemoteIdentity.
10637        '''
10638
10639    def __repr__(self):
10640        return '<sdm.RemoteIdentityGetResponse ' + \
10641            'meta: ' + repr(self.meta) + ' ' +\
10642            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10643            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10644            '>'
10645
10646    def to_dict(self):
10647        return {
10648            'meta': self.meta,
10649            'rate_limit': self.rate_limit,
10650            'remote_identity': self.remote_identity,
10651        }
10652
10653    @classmethod
10654    def from_dict(cls, d):
10655        return cls(
10656            meta=d.get('meta'),
10657            rate_limit=d.get('rate_limit'),
10658            remote_identity=d.get('remote_identity'),
10659        )
10660
10661
10662class RemoteIdentityGroup:
10663    '''
10664     A RemoteIdentityGroup defines a group of remote identities.
10665    '''
10666    __slots__ = [
10667        'id',
10668        'name',
10669    ]
10670
10671    def __init__(
10672        self,
10673        id=None,
10674        name=None,
10675    ):
10676        self.id = id if id is not None else ''
10677        '''
10678         Unique identifier of the RemoteIdentityGroup.
10679        '''
10680        self.name = name if name is not None else ''
10681        '''
10682         Unique human-readable name of the RemoteIdentityGroup.
10683        '''
10684
10685    def __repr__(self):
10686        return '<sdm.RemoteIdentityGroup ' + \
10687            'id: ' + repr(self.id) + ' ' +\
10688            'name: ' + repr(self.name) + ' ' +\
10689            '>'
10690
10691    def to_dict(self):
10692        return {
10693            'id': self.id,
10694            'name': self.name,
10695        }
10696
10697    @classmethod
10698    def from_dict(cls, d):
10699        return cls(
10700            id=d.get('id'),
10701            name=d.get('name'),
10702        )
10703
10704
10705class RemoteIdentityGroupGetResponse:
10706    '''
10707     RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
10708    '''
10709    __slots__ = [
10710        'meta',
10711        'rate_limit',
10712        'remote_identity_group',
10713    ]
10714
10715    def __init__(
10716        self,
10717        meta=None,
10718        rate_limit=None,
10719        remote_identity_group=None,
10720    ):
10721        self.meta = meta if meta is not None else None
10722        '''
10723         Reserved for future use.
10724        '''
10725        self.rate_limit = rate_limit if rate_limit is not None else None
10726        '''
10727         Rate limit information.
10728        '''
10729        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10730        '''
10731         The requested RemoteIdentityGroup.
10732        '''
10733
10734    def __repr__(self):
10735        return '<sdm.RemoteIdentityGroupGetResponse ' + \
10736            'meta: ' + repr(self.meta) + ' ' +\
10737            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10738            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
10739            '>'
10740
10741    def to_dict(self):
10742        return {
10743            'meta': self.meta,
10744            'rate_limit': self.rate_limit,
10745            'remote_identity_group': self.remote_identity_group,
10746        }
10747
10748    @classmethod
10749    def from_dict(cls, d):
10750        return cls(
10751            meta=d.get('meta'),
10752            rate_limit=d.get('rate_limit'),
10753            remote_identity_group=d.get('remote_identity_group'),
10754        )
10755
10756
10757class RemoteIdentityUpdateResponse:
10758    '''
10759     RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
10760     a RemoteIdentityUpdateRequest.
10761    '''
10762    __slots__ = [
10763        'meta',
10764        'rate_limit',
10765        'remote_identity',
10766    ]
10767
10768    def __init__(
10769        self,
10770        meta=None,
10771        rate_limit=None,
10772        remote_identity=None,
10773    ):
10774        self.meta = meta if meta is not None else None
10775        '''
10776         Reserved for future use.
10777        '''
10778        self.rate_limit = rate_limit if rate_limit is not None else None
10779        '''
10780         Rate limit information.
10781        '''
10782        self.remote_identity = remote_identity if remote_identity is not None else None
10783        '''
10784         The updated RemoteIdentity.
10785        '''
10786
10787    def __repr__(self):
10788        return '<sdm.RemoteIdentityUpdateResponse ' + \
10789            'meta: ' + repr(self.meta) + ' ' +\
10790            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10791            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10792            '>'
10793
10794    def to_dict(self):
10795        return {
10796            'meta': self.meta,
10797            'rate_limit': self.rate_limit,
10798            'remote_identity': self.remote_identity,
10799        }
10800
10801    @classmethod
10802    def from_dict(cls, d):
10803        return cls(
10804            meta=d.get('meta'),
10805            rate_limit=d.get('rate_limit'),
10806            remote_identity=d.get('remote_identity'),
10807        )
10808
10809
10810class ResourceCreateResponse:
10811    '''
10812     ResourceCreateResponse reports how the Resources were created in the system.
10813    '''
10814    __slots__ = [
10815        'meta',
10816        'rate_limit',
10817        'resource',
10818    ]
10819
10820    def __init__(
10821        self,
10822        meta=None,
10823        rate_limit=None,
10824        resource=None,
10825    ):
10826        self.meta = meta if meta is not None else None
10827        '''
10828         Reserved for future use.
10829        '''
10830        self.rate_limit = rate_limit if rate_limit is not None else None
10831        '''
10832         Rate limit information.
10833        '''
10834        self.resource = resource if resource is not None else None
10835        '''
10836         The created Resource.
10837        '''
10838
10839    def __repr__(self):
10840        return '<sdm.ResourceCreateResponse ' + \
10841            'meta: ' + repr(self.meta) + ' ' +\
10842            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10843            'resource: ' + repr(self.resource) + ' ' +\
10844            '>'
10845
10846    def to_dict(self):
10847        return {
10848            'meta': self.meta,
10849            'rate_limit': self.rate_limit,
10850            'resource': self.resource,
10851        }
10852
10853    @classmethod
10854    def from_dict(cls, d):
10855        return cls(
10856            meta=d.get('meta'),
10857            rate_limit=d.get('rate_limit'),
10858            resource=d.get('resource'),
10859        )
10860
10861
10862class ResourceDeleteResponse:
10863    '''
10864     ResourceDeleteResponse returns information about a Resource that was deleted.
10865    '''
10866    __slots__ = [
10867        'meta',
10868        'rate_limit',
10869    ]
10870
10871    def __init__(
10872        self,
10873        meta=None,
10874        rate_limit=None,
10875    ):
10876        self.meta = meta if meta is not None else None
10877        '''
10878         Reserved for future use.
10879        '''
10880        self.rate_limit = rate_limit if rate_limit is not None else None
10881        '''
10882         Rate limit information.
10883        '''
10884
10885    def __repr__(self):
10886        return '<sdm.ResourceDeleteResponse ' + \
10887            'meta: ' + repr(self.meta) + ' ' +\
10888            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10889            '>'
10890
10891    def to_dict(self):
10892        return {
10893            'meta': self.meta,
10894            'rate_limit': self.rate_limit,
10895        }
10896
10897    @classmethod
10898    def from_dict(cls, d):
10899        return cls(
10900            meta=d.get('meta'),
10901            rate_limit=d.get('rate_limit'),
10902        )
10903
10904
10905class ResourceGetResponse:
10906    '''
10907     ResourceGetResponse returns a requested Resource.
10908    '''
10909    __slots__ = [
10910        'meta',
10911        'rate_limit',
10912        'resource',
10913    ]
10914
10915    def __init__(
10916        self,
10917        meta=None,
10918        rate_limit=None,
10919        resource=None,
10920    ):
10921        self.meta = meta if meta is not None else None
10922        '''
10923         Reserved for future use.
10924        '''
10925        self.rate_limit = rate_limit if rate_limit is not None else None
10926        '''
10927         Rate limit information.
10928        '''
10929        self.resource = resource if resource is not None else None
10930        '''
10931         The requested Resource.
10932        '''
10933
10934    def __repr__(self):
10935        return '<sdm.ResourceGetResponse ' + \
10936            'meta: ' + repr(self.meta) + ' ' +\
10937            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10938            'resource: ' + repr(self.resource) + ' ' +\
10939            '>'
10940
10941    def to_dict(self):
10942        return {
10943            'meta': self.meta,
10944            'rate_limit': self.rate_limit,
10945            'resource': self.resource,
10946        }
10947
10948    @classmethod
10949    def from_dict(cls, d):
10950        return cls(
10951            meta=d.get('meta'),
10952            rate_limit=d.get('rate_limit'),
10953            resource=d.get('resource'),
10954        )
10955
10956
10957class ResourceUpdateResponse:
10958    '''
10959     ResourceUpdateResponse returns the fields of a Resource after it has been updated by
10960     a ResourceUpdateRequest.
10961    '''
10962    __slots__ = [
10963        'meta',
10964        'rate_limit',
10965        'resource',
10966    ]
10967
10968    def __init__(
10969        self,
10970        meta=None,
10971        rate_limit=None,
10972        resource=None,
10973    ):
10974        self.meta = meta if meta is not None else None
10975        '''
10976         Reserved for future use.
10977        '''
10978        self.rate_limit = rate_limit if rate_limit is not None else None
10979        '''
10980         Rate limit information.
10981        '''
10982        self.resource = resource if resource is not None else None
10983        '''
10984         The updated Resource.
10985        '''
10986
10987    def __repr__(self):
10988        return '<sdm.ResourceUpdateResponse ' + \
10989            'meta: ' + repr(self.meta) + ' ' +\
10990            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10991            'resource: ' + repr(self.resource) + ' ' +\
10992            '>'
10993
10994    def to_dict(self):
10995        return {
10996            'meta': self.meta,
10997            'rate_limit': self.rate_limit,
10998            'resource': self.resource,
10999        }
11000
11001    @classmethod
11002    def from_dict(cls, d):
11003        return cls(
11004            meta=d.get('meta'),
11005            rate_limit=d.get('rate_limit'),
11006            resource=d.get('resource'),
11007        )
11008
11009
11010class Role:
11011    '''
11012     A Role has a list of access rules which determine which Resources the members
11013     of the Role have access to. An Account can be a member of multiple Roles via
11014     AccountAttachments.
11015    '''
11016    __slots__ = [
11017        'access_rules',
11018        'id',
11019        'name',
11020        'tags',
11021    ]
11022
11023    def __init__(
11024        self,
11025        access_rules=None,
11026        id=None,
11027        name=None,
11028        tags=None,
11029    ):
11030        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
11031        )
11032        '''
11033         AccessRules is a list of access rules defining the resources this Role has access to.
11034        '''
11035        self.id = id if id is not None else ''
11036        '''
11037         Unique identifier of the Role.
11038        '''
11039        self.name = name if name is not None else ''
11040        '''
11041         Unique human-readable name of the Role.
11042        '''
11043        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11044        '''
11045         Tags is a map of key, value pairs.
11046        '''
11047
11048    def __repr__(self):
11049        return '<sdm.Role ' + \
11050            'access_rules: ' + repr(self.access_rules) + ' ' +\
11051            'id: ' + repr(self.id) + ' ' +\
11052            'name: ' + repr(self.name) + ' ' +\
11053            'tags: ' + repr(self.tags) + ' ' +\
11054            '>'
11055
11056    def to_dict(self):
11057        return {
11058            'access_rules': self.access_rules,
11059            'id': self.id,
11060            'name': self.name,
11061            'tags': self.tags,
11062        }
11063
11064    @classmethod
11065    def from_dict(cls, d):
11066        return cls(
11067            access_rules=d.get('access_rules'),
11068            id=d.get('id'),
11069            name=d.get('name'),
11070            tags=d.get('tags'),
11071        )
11072
11073
11074class RoleCreateResponse:
11075    '''
11076     RoleCreateResponse reports how the Roles were created in the system. It can
11077     communicate partial successes or failures.
11078    '''
11079    __slots__ = [
11080        'meta',
11081        'rate_limit',
11082        'role',
11083    ]
11084
11085    def __init__(
11086        self,
11087        meta=None,
11088        rate_limit=None,
11089        role=None,
11090    ):
11091        self.meta = meta if meta is not None else None
11092        '''
11093         Reserved for future use.
11094        '''
11095        self.rate_limit = rate_limit if rate_limit is not None else None
11096        '''
11097         Rate limit information.
11098        '''
11099        self.role = role if role is not None else None
11100        '''
11101         The created Role.
11102        '''
11103
11104    def __repr__(self):
11105        return '<sdm.RoleCreateResponse ' + \
11106            'meta: ' + repr(self.meta) + ' ' +\
11107            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11108            'role: ' + repr(self.role) + ' ' +\
11109            '>'
11110
11111    def to_dict(self):
11112        return {
11113            'meta': self.meta,
11114            'rate_limit': self.rate_limit,
11115            'role': self.role,
11116        }
11117
11118    @classmethod
11119    def from_dict(cls, d):
11120        return cls(
11121            meta=d.get('meta'),
11122            rate_limit=d.get('rate_limit'),
11123            role=d.get('role'),
11124        )
11125
11126
11127class RoleDeleteResponse:
11128    '''
11129     RoleDeleteResponse returns information about a Role that was deleted.
11130    '''
11131    __slots__ = [
11132        'meta',
11133        'rate_limit',
11134    ]
11135
11136    def __init__(
11137        self,
11138        meta=None,
11139        rate_limit=None,
11140    ):
11141        self.meta = meta if meta is not None else None
11142        '''
11143         Reserved for future use.
11144        '''
11145        self.rate_limit = rate_limit if rate_limit is not None else None
11146        '''
11147         Rate limit information.
11148        '''
11149
11150    def __repr__(self):
11151        return '<sdm.RoleDeleteResponse ' + \
11152            'meta: ' + repr(self.meta) + ' ' +\
11153            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11154            '>'
11155
11156    def to_dict(self):
11157        return {
11158            'meta': self.meta,
11159            'rate_limit': self.rate_limit,
11160        }
11161
11162    @classmethod
11163    def from_dict(cls, d):
11164        return cls(
11165            meta=d.get('meta'),
11166            rate_limit=d.get('rate_limit'),
11167        )
11168
11169
11170class RoleGetResponse:
11171    '''
11172     RoleGetResponse returns a requested Role.
11173    '''
11174    __slots__ = [
11175        'meta',
11176        'rate_limit',
11177        'role',
11178    ]
11179
11180    def __init__(
11181        self,
11182        meta=None,
11183        rate_limit=None,
11184        role=None,
11185    ):
11186        self.meta = meta if meta is not None else None
11187        '''
11188         Reserved for future use.
11189        '''
11190        self.rate_limit = rate_limit if rate_limit is not None else None
11191        '''
11192         Rate limit information.
11193        '''
11194        self.role = role if role is not None else None
11195        '''
11196         The requested Role.
11197        '''
11198
11199    def __repr__(self):
11200        return '<sdm.RoleGetResponse ' + \
11201            'meta: ' + repr(self.meta) + ' ' +\
11202            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11203            'role: ' + repr(self.role) + ' ' +\
11204            '>'
11205
11206    def to_dict(self):
11207        return {
11208            'meta': self.meta,
11209            'rate_limit': self.rate_limit,
11210            'role': self.role,
11211        }
11212
11213    @classmethod
11214    def from_dict(cls, d):
11215        return cls(
11216            meta=d.get('meta'),
11217            rate_limit=d.get('rate_limit'),
11218            role=d.get('role'),
11219        )
11220
11221
11222class RoleUpdateResponse:
11223    '''
11224     RoleUpdateResponse returns the fields of a Role after it has been updated by
11225     a RoleUpdateRequest.
11226    '''
11227    __slots__ = [
11228        'meta',
11229        'rate_limit',
11230        'role',
11231    ]
11232
11233    def __init__(
11234        self,
11235        meta=None,
11236        rate_limit=None,
11237        role=None,
11238    ):
11239        self.meta = meta if meta is not None else None
11240        '''
11241         Reserved for future use.
11242        '''
11243        self.rate_limit = rate_limit if rate_limit is not None else None
11244        '''
11245         Rate limit information.
11246        '''
11247        self.role = role if role is not None else None
11248        '''
11249         The updated Role.
11250        '''
11251
11252    def __repr__(self):
11253        return '<sdm.RoleUpdateResponse ' + \
11254            'meta: ' + repr(self.meta) + ' ' +\
11255            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11256            'role: ' + repr(self.role) + ' ' +\
11257            '>'
11258
11259    def to_dict(self):
11260        return {
11261            'meta': self.meta,
11262            'rate_limit': self.rate_limit,
11263            'role': self.role,
11264        }
11265
11266    @classmethod
11267    def from_dict(cls, d):
11268        return cls(
11269            meta=d.get('meta'),
11270            rate_limit=d.get('rate_limit'),
11271            role=d.get('role'),
11272        )
11273
11274
11275class SQLServer:
11276    '''
11277
11278    '''
11279    __slots__ = [
11280        'bind_interface',
11281        'database',
11282        'egress_filter',
11283        'healthy',
11284        'hostname',
11285        'id',
11286        'name',
11287        'override_database',
11288        'password',
11289        'port',
11290        'port_override',
11291        'schema',
11292        'secret_store_id',
11293        'tags',
11294        'username',
11295    ]
11296
11297    def __init__(
11298        self,
11299        bind_interface=None,
11300        database=None,
11301        egress_filter=None,
11302        healthy=None,
11303        hostname=None,
11304        id=None,
11305        name=None,
11306        override_database=None,
11307        password=None,
11308        port=None,
11309        port_override=None,
11310        schema=None,
11311        secret_store_id=None,
11312        tags=None,
11313        username=None,
11314    ):
11315        self.bind_interface = bind_interface if bind_interface is not None else ''
11316        '''
11317         Bind interface
11318        '''
11319        self.database = database if database is not None else ''
11320        '''
11321
11322        '''
11323        self.egress_filter = egress_filter if egress_filter is not None else ''
11324        '''
11325         A filter applied to the routing logic to pin datasource to nodes.
11326        '''
11327        self.healthy = healthy if healthy is not None else False
11328        '''
11329         True if the datasource is reachable and the credentials are valid.
11330        '''
11331        self.hostname = hostname if hostname is not None else ''
11332        '''
11333
11334        '''
11335        self.id = id if id is not None else ''
11336        '''
11337         Unique identifier of the Resource.
11338        '''
11339        self.name = name if name is not None else ''
11340        '''
11341         Unique human-readable name of the Resource.
11342        '''
11343        self.override_database = override_database if override_database is not None else False
11344        '''
11345
11346        '''
11347        self.password = password if password is not None else ''
11348        '''
11349
11350        '''
11351        self.port = port if port is not None else 0
11352        '''
11353
11354        '''
11355        self.port_override = port_override if port_override is not None else 0
11356        '''
11357
11358        '''
11359        self.schema = schema if schema is not None else ''
11360        '''
11361
11362        '''
11363        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11364        '''
11365         ID of the secret store containing credentials for this resource, if any.
11366        '''
11367        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11368        '''
11369         Tags is a map of key, value pairs.
11370        '''
11371        self.username = username if username is not None else ''
11372        '''
11373
11374        '''
11375
11376    def __repr__(self):
11377        return '<sdm.SQLServer ' + \
11378            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11379            'database: ' + repr(self.database) + ' ' +\
11380            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11381            'healthy: ' + repr(self.healthy) + ' ' +\
11382            'hostname: ' + repr(self.hostname) + ' ' +\
11383            'id: ' + repr(self.id) + ' ' +\
11384            'name: ' + repr(self.name) + ' ' +\
11385            'override_database: ' + repr(self.override_database) + ' ' +\
11386            'password: ' + repr(self.password) + ' ' +\
11387            'port: ' + repr(self.port) + ' ' +\
11388            'port_override: ' + repr(self.port_override) + ' ' +\
11389            'schema: ' + repr(self.schema) + ' ' +\
11390            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11391            'tags: ' + repr(self.tags) + ' ' +\
11392            'username: ' + repr(self.username) + ' ' +\
11393            '>'
11394
11395    def to_dict(self):
11396        return {
11397            'bind_interface': self.bind_interface,
11398            'database': self.database,
11399            'egress_filter': self.egress_filter,
11400            'healthy': self.healthy,
11401            'hostname': self.hostname,
11402            'id': self.id,
11403            'name': self.name,
11404            'override_database': self.override_database,
11405            'password': self.password,
11406            'port': self.port,
11407            'port_override': self.port_override,
11408            'schema': self.schema,
11409            'secret_store_id': self.secret_store_id,
11410            'tags': self.tags,
11411            'username': self.username,
11412        }
11413
11414    @classmethod
11415    def from_dict(cls, d):
11416        return cls(
11417            bind_interface=d.get('bind_interface'),
11418            database=d.get('database'),
11419            egress_filter=d.get('egress_filter'),
11420            healthy=d.get('healthy'),
11421            hostname=d.get('hostname'),
11422            id=d.get('id'),
11423            name=d.get('name'),
11424            override_database=d.get('override_database'),
11425            password=d.get('password'),
11426            port=d.get('port'),
11427            port_override=d.get('port_override'),
11428            schema=d.get('schema'),
11429            secret_store_id=d.get('secret_store_id'),
11430            tags=d.get('tags'),
11431            username=d.get('username'),
11432        )
11433
11434
11435class SSH:
11436    '''
11437
11438    '''
11439    __slots__ = [
11440        'allow_deprecated_key_exchanges',
11441        'bind_interface',
11442        'egress_filter',
11443        'healthy',
11444        'hostname',
11445        'id',
11446        'key_type',
11447        'name',
11448        'port',
11449        'port_forwarding',
11450        'port_override',
11451        'public_key',
11452        'secret_store_id',
11453        'tags',
11454        'username',
11455    ]
11456
11457    def __init__(
11458        self,
11459        allow_deprecated_key_exchanges=None,
11460        bind_interface=None,
11461        egress_filter=None,
11462        healthy=None,
11463        hostname=None,
11464        id=None,
11465        key_type=None,
11466        name=None,
11467        port=None,
11468        port_forwarding=None,
11469        port_override=None,
11470        public_key=None,
11471        secret_store_id=None,
11472        tags=None,
11473        username=None,
11474    ):
11475        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11476        '''
11477
11478        '''
11479        self.bind_interface = bind_interface if bind_interface is not None else ''
11480        '''
11481         Bind interface
11482        '''
11483        self.egress_filter = egress_filter if egress_filter is not None else ''
11484        '''
11485         A filter applied to the routing logic to pin datasource to nodes.
11486        '''
11487        self.healthy = healthy if healthy is not None else False
11488        '''
11489         True if the datasource is reachable and the credentials are valid.
11490        '''
11491        self.hostname = hostname if hostname is not None else ''
11492        '''
11493
11494        '''
11495        self.id = id if id is not None else ''
11496        '''
11497         Unique identifier of the Resource.
11498        '''
11499        self.key_type = key_type if key_type is not None else ''
11500        '''
11501
11502        '''
11503        self.name = name if name is not None else ''
11504        '''
11505         Unique human-readable name of the Resource.
11506        '''
11507        self.port = port if port is not None else 0
11508        '''
11509
11510        '''
11511        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11512        '''
11513
11514        '''
11515        self.port_override = port_override if port_override is not None else 0
11516        '''
11517
11518        '''
11519        self.public_key = public_key if public_key is not None else ''
11520        '''
11521
11522        '''
11523        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11524        '''
11525         ID of the secret store containing credentials for this resource, if any.
11526        '''
11527        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11528        '''
11529         Tags is a map of key, value pairs.
11530        '''
11531        self.username = username if username is not None else ''
11532        '''
11533
11534        '''
11535
11536    def __repr__(self):
11537        return '<sdm.SSH ' + \
11538            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11539            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11540            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11541            'healthy: ' + repr(self.healthy) + ' ' +\
11542            'hostname: ' + repr(self.hostname) + ' ' +\
11543            'id: ' + repr(self.id) + ' ' +\
11544            'key_type: ' + repr(self.key_type) + ' ' +\
11545            'name: ' + repr(self.name) + ' ' +\
11546            'port: ' + repr(self.port) + ' ' +\
11547            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11548            'port_override: ' + repr(self.port_override) + ' ' +\
11549            'public_key: ' + repr(self.public_key) + ' ' +\
11550            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11551            'tags: ' + repr(self.tags) + ' ' +\
11552            'username: ' + repr(self.username) + ' ' +\
11553            '>'
11554
11555    def to_dict(self):
11556        return {
11557            'allow_deprecated_key_exchanges':
11558            self.allow_deprecated_key_exchanges,
11559            'bind_interface': self.bind_interface,
11560            'egress_filter': self.egress_filter,
11561            'healthy': self.healthy,
11562            'hostname': self.hostname,
11563            'id': self.id,
11564            'key_type': self.key_type,
11565            'name': self.name,
11566            'port': self.port,
11567            'port_forwarding': self.port_forwarding,
11568            'port_override': self.port_override,
11569            'public_key': self.public_key,
11570            'secret_store_id': self.secret_store_id,
11571            'tags': self.tags,
11572            'username': self.username,
11573        }
11574
11575    @classmethod
11576    def from_dict(cls, d):
11577        return cls(
11578            allow_deprecated_key_exchanges=d.get(
11579                'allow_deprecated_key_exchanges'),
11580            bind_interface=d.get('bind_interface'),
11581            egress_filter=d.get('egress_filter'),
11582            healthy=d.get('healthy'),
11583            hostname=d.get('hostname'),
11584            id=d.get('id'),
11585            key_type=d.get('key_type'),
11586            name=d.get('name'),
11587            port=d.get('port'),
11588            port_forwarding=d.get('port_forwarding'),
11589            port_override=d.get('port_override'),
11590            public_key=d.get('public_key'),
11591            secret_store_id=d.get('secret_store_id'),
11592            tags=d.get('tags'),
11593            username=d.get('username'),
11594        )
11595
11596
11597class SSHCert:
11598    '''
11599
11600    '''
11601    __slots__ = [
11602        'allow_deprecated_key_exchanges',
11603        'bind_interface',
11604        'egress_filter',
11605        'healthy',
11606        'hostname',
11607        'id',
11608        'key_type',
11609        'name',
11610        'port',
11611        'port_forwarding',
11612        'port_override',
11613        'remote_identity_group_id',
11614        'remote_identity_healthcheck_username',
11615        'secret_store_id',
11616        'tags',
11617        'username',
11618    ]
11619
11620    def __init__(
11621        self,
11622        allow_deprecated_key_exchanges=None,
11623        bind_interface=None,
11624        egress_filter=None,
11625        healthy=None,
11626        hostname=None,
11627        id=None,
11628        key_type=None,
11629        name=None,
11630        port=None,
11631        port_forwarding=None,
11632        port_override=None,
11633        remote_identity_group_id=None,
11634        remote_identity_healthcheck_username=None,
11635        secret_store_id=None,
11636        tags=None,
11637        username=None,
11638    ):
11639        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11640        '''
11641
11642        '''
11643        self.bind_interface = bind_interface if bind_interface is not None else ''
11644        '''
11645         Bind interface
11646        '''
11647        self.egress_filter = egress_filter if egress_filter is not None else ''
11648        '''
11649         A filter applied to the routing logic to pin datasource to nodes.
11650        '''
11651        self.healthy = healthy if healthy is not None else False
11652        '''
11653         True if the datasource is reachable and the credentials are valid.
11654        '''
11655        self.hostname = hostname if hostname is not None else ''
11656        '''
11657
11658        '''
11659        self.id = id if id is not None else ''
11660        '''
11661         Unique identifier of the Resource.
11662        '''
11663        self.key_type = key_type if key_type is not None else ''
11664        '''
11665
11666        '''
11667        self.name = name if name is not None else ''
11668        '''
11669         Unique human-readable name of the Resource.
11670        '''
11671        self.port = port if port is not None else 0
11672        '''
11673
11674        '''
11675        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11676        '''
11677
11678        '''
11679        self.port_override = port_override if port_override is not None else 0
11680        '''
11681
11682        '''
11683        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
11684        '''
11685
11686        '''
11687        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
11688        '''
11689
11690        '''
11691        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11692        '''
11693         ID of the secret store containing credentials for this resource, if any.
11694        '''
11695        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11696        '''
11697         Tags is a map of key, value pairs.
11698        '''
11699        self.username = username if username is not None else ''
11700        '''
11701
11702        '''
11703
11704    def __repr__(self):
11705        return '<sdm.SSHCert ' + \
11706            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11707            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11708            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11709            'healthy: ' + repr(self.healthy) + ' ' +\
11710            'hostname: ' + repr(self.hostname) + ' ' +\
11711            'id: ' + repr(self.id) + ' ' +\
11712            'key_type: ' + repr(self.key_type) + ' ' +\
11713            'name: ' + repr(self.name) + ' ' +\
11714            'port: ' + repr(self.port) + ' ' +\
11715            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11716            'port_override: ' + repr(self.port_override) + ' ' +\
11717            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
11718            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
11719            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11720            'tags: ' + repr(self.tags) + ' ' +\
11721            'username: ' + repr(self.username) + ' ' +\
11722            '>'
11723
11724    def to_dict(self):
11725        return {
11726            'allow_deprecated_key_exchanges':
11727            self.allow_deprecated_key_exchanges,
11728            'bind_interface': self.bind_interface,
11729            'egress_filter': self.egress_filter,
11730            'healthy': self.healthy,
11731            'hostname': self.hostname,
11732            'id': self.id,
11733            'key_type': self.key_type,
11734            'name': self.name,
11735            'port': self.port,
11736            'port_forwarding': self.port_forwarding,
11737            'port_override': self.port_override,
11738            'remote_identity_group_id': self.remote_identity_group_id,
11739            'remote_identity_healthcheck_username':
11740            self.remote_identity_healthcheck_username,
11741            'secret_store_id': self.secret_store_id,
11742            'tags': self.tags,
11743            'username': self.username,
11744        }
11745
11746    @classmethod
11747    def from_dict(cls, d):
11748        return cls(
11749            allow_deprecated_key_exchanges=d.get(
11750                'allow_deprecated_key_exchanges'),
11751            bind_interface=d.get('bind_interface'),
11752            egress_filter=d.get('egress_filter'),
11753            healthy=d.get('healthy'),
11754            hostname=d.get('hostname'),
11755            id=d.get('id'),
11756            key_type=d.get('key_type'),
11757            name=d.get('name'),
11758            port=d.get('port'),
11759            port_forwarding=d.get('port_forwarding'),
11760            port_override=d.get('port_override'),
11761            remote_identity_group_id=d.get('remote_identity_group_id'),
11762            remote_identity_healthcheck_username=d.get(
11763                'remote_identity_healthcheck_username'),
11764            secret_store_id=d.get('secret_store_id'),
11765            tags=d.get('tags'),
11766            username=d.get('username'),
11767        )
11768
11769
11770class SSHCustomerKey:
11771    '''
11772
11773    '''
11774    __slots__ = [
11775        'allow_deprecated_key_exchanges',
11776        'bind_interface',
11777        'egress_filter',
11778        'healthy',
11779        'hostname',
11780        'id',
11781        'name',
11782        'port',
11783        'port_forwarding',
11784        'port_override',
11785        'private_key',
11786        'secret_store_id',
11787        'tags',
11788        'username',
11789    ]
11790
11791    def __init__(
11792        self,
11793        allow_deprecated_key_exchanges=None,
11794        bind_interface=None,
11795        egress_filter=None,
11796        healthy=None,
11797        hostname=None,
11798        id=None,
11799        name=None,
11800        port=None,
11801        port_forwarding=None,
11802        port_override=None,
11803        private_key=None,
11804        secret_store_id=None,
11805        tags=None,
11806        username=None,
11807    ):
11808        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11809        '''
11810
11811        '''
11812        self.bind_interface = bind_interface if bind_interface is not None else ''
11813        '''
11814         Bind interface
11815        '''
11816        self.egress_filter = egress_filter if egress_filter is not None else ''
11817        '''
11818         A filter applied to the routing logic to pin datasource to nodes.
11819        '''
11820        self.healthy = healthy if healthy is not None else False
11821        '''
11822         True if the datasource is reachable and the credentials are valid.
11823        '''
11824        self.hostname = hostname if hostname is not None else ''
11825        '''
11826
11827        '''
11828        self.id = id if id is not None else ''
11829        '''
11830         Unique identifier of the Resource.
11831        '''
11832        self.name = name if name is not None else ''
11833        '''
11834         Unique human-readable name of the Resource.
11835        '''
11836        self.port = port if port is not None else 0
11837        '''
11838
11839        '''
11840        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11841        '''
11842
11843        '''
11844        self.port_override = port_override if port_override is not None else 0
11845        '''
11846
11847        '''
11848        self.private_key = private_key if private_key is not None else ''
11849        '''
11850
11851        '''
11852        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11853        '''
11854         ID of the secret store containing credentials for this resource, if any.
11855        '''
11856        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11857        '''
11858         Tags is a map of key, value pairs.
11859        '''
11860        self.username = username if username is not None else ''
11861        '''
11862
11863        '''
11864
11865    def __repr__(self):
11866        return '<sdm.SSHCustomerKey ' + \
11867            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11868            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11869            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11870            'healthy: ' + repr(self.healthy) + ' ' +\
11871            'hostname: ' + repr(self.hostname) + ' ' +\
11872            'id: ' + repr(self.id) + ' ' +\
11873            'name: ' + repr(self.name) + ' ' +\
11874            'port: ' + repr(self.port) + ' ' +\
11875            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11876            'port_override: ' + repr(self.port_override) + ' ' +\
11877            'private_key: ' + repr(self.private_key) + ' ' +\
11878            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11879            'tags: ' + repr(self.tags) + ' ' +\
11880            'username: ' + repr(self.username) + ' ' +\
11881            '>'
11882
11883    def to_dict(self):
11884        return {
11885            'allow_deprecated_key_exchanges':
11886            self.allow_deprecated_key_exchanges,
11887            'bind_interface': self.bind_interface,
11888            'egress_filter': self.egress_filter,
11889            'healthy': self.healthy,
11890            'hostname': self.hostname,
11891            'id': self.id,
11892            'name': self.name,
11893            'port': self.port,
11894            'port_forwarding': self.port_forwarding,
11895            'port_override': self.port_override,
11896            'private_key': self.private_key,
11897            'secret_store_id': self.secret_store_id,
11898            'tags': self.tags,
11899            'username': self.username,
11900        }
11901
11902    @classmethod
11903    def from_dict(cls, d):
11904        return cls(
11905            allow_deprecated_key_exchanges=d.get(
11906                'allow_deprecated_key_exchanges'),
11907            bind_interface=d.get('bind_interface'),
11908            egress_filter=d.get('egress_filter'),
11909            healthy=d.get('healthy'),
11910            hostname=d.get('hostname'),
11911            id=d.get('id'),
11912            name=d.get('name'),
11913            port=d.get('port'),
11914            port_forwarding=d.get('port_forwarding'),
11915            port_override=d.get('port_override'),
11916            private_key=d.get('private_key'),
11917            secret_store_id=d.get('secret_store_id'),
11918            tags=d.get('tags'),
11919            username=d.get('username'),
11920        )
11921
11922
11923class SecretStoreCreateResponse:
11924    '''
11925     SecretStoreCreateResponse reports how the SecretStores were created in the system.
11926    '''
11927    __slots__ = [
11928        'meta',
11929        'rate_limit',
11930        'secret_store',
11931    ]
11932
11933    def __init__(
11934        self,
11935        meta=None,
11936        rate_limit=None,
11937        secret_store=None,
11938    ):
11939        self.meta = meta if meta is not None else None
11940        '''
11941         Reserved for future use.
11942        '''
11943        self.rate_limit = rate_limit if rate_limit is not None else None
11944        '''
11945         Rate limit information.
11946        '''
11947        self.secret_store = secret_store if secret_store is not None else None
11948        '''
11949         The created SecretStore.
11950        '''
11951
11952    def __repr__(self):
11953        return '<sdm.SecretStoreCreateResponse ' + \
11954            'meta: ' + repr(self.meta) + ' ' +\
11955            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11956            'secret_store: ' + repr(self.secret_store) + ' ' +\
11957            '>'
11958
11959    def to_dict(self):
11960        return {
11961            'meta': self.meta,
11962            'rate_limit': self.rate_limit,
11963            'secret_store': self.secret_store,
11964        }
11965
11966    @classmethod
11967    def from_dict(cls, d):
11968        return cls(
11969            meta=d.get('meta'),
11970            rate_limit=d.get('rate_limit'),
11971            secret_store=d.get('secret_store'),
11972        )
11973
11974
11975class SecretStoreDeleteResponse:
11976    '''
11977     SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
11978    '''
11979    __slots__ = [
11980        'meta',
11981        'rate_limit',
11982    ]
11983
11984    def __init__(
11985        self,
11986        meta=None,
11987        rate_limit=None,
11988    ):
11989        self.meta = meta if meta is not None else None
11990        '''
11991         Reserved for future use.
11992        '''
11993        self.rate_limit = rate_limit if rate_limit is not None else None
11994        '''
11995         Rate limit information.
11996        '''
11997
11998    def __repr__(self):
11999        return '<sdm.SecretStoreDeleteResponse ' + \
12000            'meta: ' + repr(self.meta) + ' ' +\
12001            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12002            '>'
12003
12004    def to_dict(self):
12005        return {
12006            'meta': self.meta,
12007            'rate_limit': self.rate_limit,
12008        }
12009
12010    @classmethod
12011    def from_dict(cls, d):
12012        return cls(
12013            meta=d.get('meta'),
12014            rate_limit=d.get('rate_limit'),
12015        )
12016
12017
12018class SecretStoreGetResponse:
12019    '''
12020     SecretStoreGetResponse returns a requested SecretStore.
12021    '''
12022    __slots__ = [
12023        'meta',
12024        'rate_limit',
12025        'secret_store',
12026    ]
12027
12028    def __init__(
12029        self,
12030        meta=None,
12031        rate_limit=None,
12032        secret_store=None,
12033    ):
12034        self.meta = meta if meta is not None else None
12035        '''
12036         Reserved for future use.
12037        '''
12038        self.rate_limit = rate_limit if rate_limit is not None else None
12039        '''
12040         Rate limit information.
12041        '''
12042        self.secret_store = secret_store if secret_store is not None else None
12043        '''
12044         The requested SecretStore.
12045        '''
12046
12047    def __repr__(self):
12048        return '<sdm.SecretStoreGetResponse ' + \
12049            'meta: ' + repr(self.meta) + ' ' +\
12050            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12051            'secret_store: ' + repr(self.secret_store) + ' ' +\
12052            '>'
12053
12054    def to_dict(self):
12055        return {
12056            'meta': self.meta,
12057            'rate_limit': self.rate_limit,
12058            'secret_store': self.secret_store,
12059        }
12060
12061    @classmethod
12062    def from_dict(cls, d):
12063        return cls(
12064            meta=d.get('meta'),
12065            rate_limit=d.get('rate_limit'),
12066            secret_store=d.get('secret_store'),
12067        )
12068
12069
12070class SecretStoreUpdateResponse:
12071    '''
12072     SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
12073     a SecretStoreUpdateRequest.
12074    '''
12075    __slots__ = [
12076        'meta',
12077        'rate_limit',
12078        'secret_store',
12079    ]
12080
12081    def __init__(
12082        self,
12083        meta=None,
12084        rate_limit=None,
12085        secret_store=None,
12086    ):
12087        self.meta = meta if meta is not None else None
12088        '''
12089         Reserved for future use.
12090        '''
12091        self.rate_limit = rate_limit if rate_limit is not None else None
12092        '''
12093         Rate limit information.
12094        '''
12095        self.secret_store = secret_store if secret_store is not None else None
12096        '''
12097         The updated SecretStore.
12098        '''
12099
12100    def __repr__(self):
12101        return '<sdm.SecretStoreUpdateResponse ' + \
12102            'meta: ' + repr(self.meta) + ' ' +\
12103            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12104            'secret_store: ' + repr(self.secret_store) + ' ' +\
12105            '>'
12106
12107    def to_dict(self):
12108        return {
12109            'meta': self.meta,
12110            'rate_limit': self.rate_limit,
12111            'secret_store': self.secret_store,
12112        }
12113
12114    @classmethod
12115    def from_dict(cls, d):
12116        return cls(
12117            meta=d.get('meta'),
12118            rate_limit=d.get('rate_limit'),
12119            secret_store=d.get('secret_store'),
12120        )
12121
12122
12123class Service:
12124    '''
12125     A Service is a service account that can connect to resources they are granted
12126     directly, or granted via roles. Services are typically automated jobs.
12127    '''
12128    __slots__ = [
12129        'id',
12130        'name',
12131        'suspended',
12132        'tags',
12133    ]
12134
12135    def __init__(
12136        self,
12137        id=None,
12138        name=None,
12139        suspended=None,
12140        tags=None,
12141    ):
12142        self.id = id if id is not None else ''
12143        '''
12144         Unique identifier of the Service.
12145        '''
12146        self.name = name if name is not None else ''
12147        '''
12148         Unique human-readable name of the Service.
12149        '''
12150        self.suspended = suspended if suspended is not None else False
12151        '''
12152         The Service's suspended state.
12153        '''
12154        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12155        '''
12156         Tags is a map of key, value pairs.
12157        '''
12158
12159    def __repr__(self):
12160        return '<sdm.Service ' + \
12161            'id: ' + repr(self.id) + ' ' +\
12162            'name: ' + repr(self.name) + ' ' +\
12163            'suspended: ' + repr(self.suspended) + ' ' +\
12164            'tags: ' + repr(self.tags) + ' ' +\
12165            '>'
12166
12167    def to_dict(self):
12168        return {
12169            'id': self.id,
12170            'name': self.name,
12171            'suspended': self.suspended,
12172            'tags': self.tags,
12173        }
12174
12175    @classmethod
12176    def from_dict(cls, d):
12177        return cls(
12178            id=d.get('id'),
12179            name=d.get('name'),
12180            suspended=d.get('suspended'),
12181            tags=d.get('tags'),
12182        )
12183
12184
12185class SingleStore:
12186    '''
12187
12188    '''
12189    __slots__ = [
12190        'bind_interface',
12191        'database',
12192        'egress_filter',
12193        'healthy',
12194        'hostname',
12195        'id',
12196        'name',
12197        'password',
12198        'port',
12199        'port_override',
12200        'secret_store_id',
12201        'tags',
12202        'username',
12203    ]
12204
12205    def __init__(
12206        self,
12207        bind_interface=None,
12208        database=None,
12209        egress_filter=None,
12210        healthy=None,
12211        hostname=None,
12212        id=None,
12213        name=None,
12214        password=None,
12215        port=None,
12216        port_override=None,
12217        secret_store_id=None,
12218        tags=None,
12219        username=None,
12220    ):
12221        self.bind_interface = bind_interface if bind_interface is not None else ''
12222        '''
12223         Bind interface
12224        '''
12225        self.database = database if database is not None else ''
12226        '''
12227
12228        '''
12229        self.egress_filter = egress_filter if egress_filter is not None else ''
12230        '''
12231         A filter applied to the routing logic to pin datasource to nodes.
12232        '''
12233        self.healthy = healthy if healthy is not None else False
12234        '''
12235         True if the datasource is reachable and the credentials are valid.
12236        '''
12237        self.hostname = hostname if hostname is not None else ''
12238        '''
12239
12240        '''
12241        self.id = id if id is not None else ''
12242        '''
12243         Unique identifier of the Resource.
12244        '''
12245        self.name = name if name is not None else ''
12246        '''
12247         Unique human-readable name of the Resource.
12248        '''
12249        self.password = password if password is not None else ''
12250        '''
12251
12252        '''
12253        self.port = port if port is not None else 0
12254        '''
12255
12256        '''
12257        self.port_override = port_override if port_override is not None else 0
12258        '''
12259
12260        '''
12261        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12262        '''
12263         ID of the secret store containing credentials for this resource, if any.
12264        '''
12265        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12266        '''
12267         Tags is a map of key, value pairs.
12268        '''
12269        self.username = username if username is not None else ''
12270        '''
12271
12272        '''
12273
12274    def __repr__(self):
12275        return '<sdm.SingleStore ' + \
12276            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12277            'database: ' + repr(self.database) + ' ' +\
12278            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12279            'healthy: ' + repr(self.healthy) + ' ' +\
12280            'hostname: ' + repr(self.hostname) + ' ' +\
12281            'id: ' + repr(self.id) + ' ' +\
12282            'name: ' + repr(self.name) + ' ' +\
12283            'password: ' + repr(self.password) + ' ' +\
12284            'port: ' + repr(self.port) + ' ' +\
12285            'port_override: ' + repr(self.port_override) + ' ' +\
12286            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12287            'tags: ' + repr(self.tags) + ' ' +\
12288            'username: ' + repr(self.username) + ' ' +\
12289            '>'
12290
12291    def to_dict(self):
12292        return {
12293            'bind_interface': self.bind_interface,
12294            'database': self.database,
12295            'egress_filter': self.egress_filter,
12296            'healthy': self.healthy,
12297            'hostname': self.hostname,
12298            'id': self.id,
12299            'name': self.name,
12300            'password': self.password,
12301            'port': self.port,
12302            'port_override': self.port_override,
12303            'secret_store_id': self.secret_store_id,
12304            'tags': self.tags,
12305            'username': self.username,
12306        }
12307
12308    @classmethod
12309    def from_dict(cls, d):
12310        return cls(
12311            bind_interface=d.get('bind_interface'),
12312            database=d.get('database'),
12313            egress_filter=d.get('egress_filter'),
12314            healthy=d.get('healthy'),
12315            hostname=d.get('hostname'),
12316            id=d.get('id'),
12317            name=d.get('name'),
12318            password=d.get('password'),
12319            port=d.get('port'),
12320            port_override=d.get('port_override'),
12321            secret_store_id=d.get('secret_store_id'),
12322            tags=d.get('tags'),
12323            username=d.get('username'),
12324        )
12325
12326
12327class Snowflake:
12328    '''
12329
12330    '''
12331    __slots__ = [
12332        'bind_interface',
12333        'database',
12334        'egress_filter',
12335        'healthy',
12336        'hostname',
12337        'id',
12338        'name',
12339        'password',
12340        'port_override',
12341        'schema',
12342        'secret_store_id',
12343        'tags',
12344        'username',
12345    ]
12346
12347    def __init__(
12348        self,
12349        bind_interface=None,
12350        database=None,
12351        egress_filter=None,
12352        healthy=None,
12353        hostname=None,
12354        id=None,
12355        name=None,
12356        password=None,
12357        port_override=None,
12358        schema=None,
12359        secret_store_id=None,
12360        tags=None,
12361        username=None,
12362    ):
12363        self.bind_interface = bind_interface if bind_interface is not None else ''
12364        '''
12365         Bind interface
12366        '''
12367        self.database = database if database is not None else ''
12368        '''
12369
12370        '''
12371        self.egress_filter = egress_filter if egress_filter is not None else ''
12372        '''
12373         A filter applied to the routing logic to pin datasource to nodes.
12374        '''
12375        self.healthy = healthy if healthy is not None else False
12376        '''
12377         True if the datasource is reachable and the credentials are valid.
12378        '''
12379        self.hostname = hostname if hostname is not None else ''
12380        '''
12381
12382        '''
12383        self.id = id if id is not None else ''
12384        '''
12385         Unique identifier of the Resource.
12386        '''
12387        self.name = name if name is not None else ''
12388        '''
12389         Unique human-readable name of the Resource.
12390        '''
12391        self.password = password if password is not None else ''
12392        '''
12393
12394        '''
12395        self.port_override = port_override if port_override is not None else 0
12396        '''
12397
12398        '''
12399        self.schema = schema if schema is not None else ''
12400        '''
12401
12402        '''
12403        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12404        '''
12405         ID of the secret store containing credentials for this resource, if any.
12406        '''
12407        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12408        '''
12409         Tags is a map of key, value pairs.
12410        '''
12411        self.username = username if username is not None else ''
12412        '''
12413
12414        '''
12415
12416    def __repr__(self):
12417        return '<sdm.Snowflake ' + \
12418            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12419            'database: ' + repr(self.database) + ' ' +\
12420            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12421            'healthy: ' + repr(self.healthy) + ' ' +\
12422            'hostname: ' + repr(self.hostname) + ' ' +\
12423            'id: ' + repr(self.id) + ' ' +\
12424            'name: ' + repr(self.name) + ' ' +\
12425            'password: ' + repr(self.password) + ' ' +\
12426            'port_override: ' + repr(self.port_override) + ' ' +\
12427            'schema: ' + repr(self.schema) + ' ' +\
12428            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12429            'tags: ' + repr(self.tags) + ' ' +\
12430            'username: ' + repr(self.username) + ' ' +\
12431            '>'
12432
12433    def to_dict(self):
12434        return {
12435            'bind_interface': self.bind_interface,
12436            'database': self.database,
12437            'egress_filter': self.egress_filter,
12438            'healthy': self.healthy,
12439            'hostname': self.hostname,
12440            'id': self.id,
12441            'name': self.name,
12442            'password': self.password,
12443            'port_override': self.port_override,
12444            'schema': self.schema,
12445            'secret_store_id': self.secret_store_id,
12446            'tags': self.tags,
12447            'username': self.username,
12448        }
12449
12450    @classmethod
12451    def from_dict(cls, d):
12452        return cls(
12453            bind_interface=d.get('bind_interface'),
12454            database=d.get('database'),
12455            egress_filter=d.get('egress_filter'),
12456            healthy=d.get('healthy'),
12457            hostname=d.get('hostname'),
12458            id=d.get('id'),
12459            name=d.get('name'),
12460            password=d.get('password'),
12461            port_override=d.get('port_override'),
12462            schema=d.get('schema'),
12463            secret_store_id=d.get('secret_store_id'),
12464            tags=d.get('tags'),
12465            username=d.get('username'),
12466        )
12467
12468
12469class Sybase:
12470    '''
12471
12472    '''
12473    __slots__ = [
12474        'bind_interface',
12475        'egress_filter',
12476        'healthy',
12477        'hostname',
12478        'id',
12479        'name',
12480        'password',
12481        'port',
12482        'port_override',
12483        'secret_store_id',
12484        'tags',
12485        'username',
12486    ]
12487
12488    def __init__(
12489        self,
12490        bind_interface=None,
12491        egress_filter=None,
12492        healthy=None,
12493        hostname=None,
12494        id=None,
12495        name=None,
12496        password=None,
12497        port=None,
12498        port_override=None,
12499        secret_store_id=None,
12500        tags=None,
12501        username=None,
12502    ):
12503        self.bind_interface = bind_interface if bind_interface is not None else ''
12504        '''
12505         Bind interface
12506        '''
12507        self.egress_filter = egress_filter if egress_filter is not None else ''
12508        '''
12509         A filter applied to the routing logic to pin datasource to nodes.
12510        '''
12511        self.healthy = healthy if healthy is not None else False
12512        '''
12513         True if the datasource is reachable and the credentials are valid.
12514        '''
12515        self.hostname = hostname if hostname is not None else ''
12516        '''
12517
12518        '''
12519        self.id = id if id is not None else ''
12520        '''
12521         Unique identifier of the Resource.
12522        '''
12523        self.name = name if name is not None else ''
12524        '''
12525         Unique human-readable name of the Resource.
12526        '''
12527        self.password = password if password is not None else ''
12528        '''
12529
12530        '''
12531        self.port = port if port is not None else 0
12532        '''
12533
12534        '''
12535        self.port_override = port_override if port_override is not None else 0
12536        '''
12537
12538        '''
12539        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12540        '''
12541         ID of the secret store containing credentials for this resource, if any.
12542        '''
12543        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12544        '''
12545         Tags is a map of key, value pairs.
12546        '''
12547        self.username = username if username is not None else ''
12548        '''
12549
12550        '''
12551
12552    def __repr__(self):
12553        return '<sdm.Sybase ' + \
12554            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12555            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12556            'healthy: ' + repr(self.healthy) + ' ' +\
12557            'hostname: ' + repr(self.hostname) + ' ' +\
12558            'id: ' + repr(self.id) + ' ' +\
12559            'name: ' + repr(self.name) + ' ' +\
12560            'password: ' + repr(self.password) + ' ' +\
12561            'port: ' + repr(self.port) + ' ' +\
12562            'port_override: ' + repr(self.port_override) + ' ' +\
12563            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12564            'tags: ' + repr(self.tags) + ' ' +\
12565            'username: ' + repr(self.username) + ' ' +\
12566            '>'
12567
12568    def to_dict(self):
12569        return {
12570            'bind_interface': self.bind_interface,
12571            'egress_filter': self.egress_filter,
12572            'healthy': self.healthy,
12573            'hostname': self.hostname,
12574            'id': self.id,
12575            'name': self.name,
12576            'password': self.password,
12577            'port': self.port,
12578            'port_override': self.port_override,
12579            'secret_store_id': self.secret_store_id,
12580            'tags': self.tags,
12581            'username': self.username,
12582        }
12583
12584    @classmethod
12585    def from_dict(cls, d):
12586        return cls(
12587            bind_interface=d.get('bind_interface'),
12588            egress_filter=d.get('egress_filter'),
12589            healthy=d.get('healthy'),
12590            hostname=d.get('hostname'),
12591            id=d.get('id'),
12592            name=d.get('name'),
12593            password=d.get('password'),
12594            port=d.get('port'),
12595            port_override=d.get('port_override'),
12596            secret_store_id=d.get('secret_store_id'),
12597            tags=d.get('tags'),
12598            username=d.get('username'),
12599        )
12600
12601
12602class SybaseIQ:
12603    '''
12604
12605    '''
12606    __slots__ = [
12607        'bind_interface',
12608        'egress_filter',
12609        'healthy',
12610        'hostname',
12611        'id',
12612        'name',
12613        'password',
12614        'port',
12615        'port_override',
12616        'secret_store_id',
12617        'tags',
12618        'username',
12619    ]
12620
12621    def __init__(
12622        self,
12623        bind_interface=None,
12624        egress_filter=None,
12625        healthy=None,
12626        hostname=None,
12627        id=None,
12628        name=None,
12629        password=None,
12630        port=None,
12631        port_override=None,
12632        secret_store_id=None,
12633        tags=None,
12634        username=None,
12635    ):
12636        self.bind_interface = bind_interface if bind_interface is not None else ''
12637        '''
12638         Bind interface
12639        '''
12640        self.egress_filter = egress_filter if egress_filter is not None else ''
12641        '''
12642         A filter applied to the routing logic to pin datasource to nodes.
12643        '''
12644        self.healthy = healthy if healthy is not None else False
12645        '''
12646         True if the datasource is reachable and the credentials are valid.
12647        '''
12648        self.hostname = hostname if hostname is not None else ''
12649        '''
12650
12651        '''
12652        self.id = id if id is not None else ''
12653        '''
12654         Unique identifier of the Resource.
12655        '''
12656        self.name = name if name is not None else ''
12657        '''
12658         Unique human-readable name of the Resource.
12659        '''
12660        self.password = password if password is not None else ''
12661        '''
12662
12663        '''
12664        self.port = port if port is not None else 0
12665        '''
12666
12667        '''
12668        self.port_override = port_override if port_override is not None else 0
12669        '''
12670
12671        '''
12672        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12673        '''
12674         ID of the secret store containing credentials for this resource, if any.
12675        '''
12676        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12677        '''
12678         Tags is a map of key, value pairs.
12679        '''
12680        self.username = username if username is not None else ''
12681        '''
12682
12683        '''
12684
12685    def __repr__(self):
12686        return '<sdm.SybaseIQ ' + \
12687            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12688            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12689            'healthy: ' + repr(self.healthy) + ' ' +\
12690            'hostname: ' + repr(self.hostname) + ' ' +\
12691            'id: ' + repr(self.id) + ' ' +\
12692            'name: ' + repr(self.name) + ' ' +\
12693            'password: ' + repr(self.password) + ' ' +\
12694            'port: ' + repr(self.port) + ' ' +\
12695            'port_override: ' + repr(self.port_override) + ' ' +\
12696            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12697            'tags: ' + repr(self.tags) + ' ' +\
12698            'username: ' + repr(self.username) + ' ' +\
12699            '>'
12700
12701    def to_dict(self):
12702        return {
12703            'bind_interface': self.bind_interface,
12704            'egress_filter': self.egress_filter,
12705            'healthy': self.healthy,
12706            'hostname': self.hostname,
12707            'id': self.id,
12708            'name': self.name,
12709            'password': self.password,
12710            'port': self.port,
12711            'port_override': self.port_override,
12712            'secret_store_id': self.secret_store_id,
12713            'tags': self.tags,
12714            'username': self.username,
12715        }
12716
12717    @classmethod
12718    def from_dict(cls, d):
12719        return cls(
12720            bind_interface=d.get('bind_interface'),
12721            egress_filter=d.get('egress_filter'),
12722            healthy=d.get('healthy'),
12723            hostname=d.get('hostname'),
12724            id=d.get('id'),
12725            name=d.get('name'),
12726            password=d.get('password'),
12727            port=d.get('port'),
12728            port_override=d.get('port_override'),
12729            secret_store_id=d.get('secret_store_id'),
12730            tags=d.get('tags'),
12731            username=d.get('username'),
12732        )
12733
12734
12735class Tag:
12736    '''
12737
12738    '''
12739    __slots__ = [
12740        'name',
12741        'value',
12742    ]
12743
12744    def __init__(
12745        self,
12746        name=None,
12747        value=None,
12748    ):
12749        self.name = name if name is not None else ''
12750        '''
12751
12752        '''
12753        self.value = value if value is not None else ''
12754        '''
12755
12756        '''
12757
12758    def __repr__(self):
12759        return '<sdm.Tag ' + \
12760            'name: ' + repr(self.name) + ' ' +\
12761            'value: ' + repr(self.value) + ' ' +\
12762            '>'
12763
12764    def to_dict(self):
12765        return {
12766            'name': self.name,
12767            'value': self.value,
12768        }
12769
12770    @classmethod
12771    def from_dict(cls, d):
12772        return cls(
12773            name=d.get('name'),
12774            value=d.get('value'),
12775        )
12776
12777
12778class Teradata:
12779    '''
12780
12781    '''
12782    __slots__ = [
12783        'bind_interface',
12784        'egress_filter',
12785        'healthy',
12786        'hostname',
12787        'id',
12788        'name',
12789        'password',
12790        'port',
12791        'port_override',
12792        'secret_store_id',
12793        'tags',
12794        'username',
12795    ]
12796
12797    def __init__(
12798        self,
12799        bind_interface=None,
12800        egress_filter=None,
12801        healthy=None,
12802        hostname=None,
12803        id=None,
12804        name=None,
12805        password=None,
12806        port=None,
12807        port_override=None,
12808        secret_store_id=None,
12809        tags=None,
12810        username=None,
12811    ):
12812        self.bind_interface = bind_interface if bind_interface is not None else ''
12813        '''
12814         Bind interface
12815        '''
12816        self.egress_filter = egress_filter if egress_filter is not None else ''
12817        '''
12818         A filter applied to the routing logic to pin datasource to nodes.
12819        '''
12820        self.healthy = healthy if healthy is not None else False
12821        '''
12822         True if the datasource is reachable and the credentials are valid.
12823        '''
12824        self.hostname = hostname if hostname is not None else ''
12825        '''
12826
12827        '''
12828        self.id = id if id is not None else ''
12829        '''
12830         Unique identifier of the Resource.
12831        '''
12832        self.name = name if name is not None else ''
12833        '''
12834         Unique human-readable name of the Resource.
12835        '''
12836        self.password = password if password is not None else ''
12837        '''
12838
12839        '''
12840        self.port = port if port is not None else 0
12841        '''
12842
12843        '''
12844        self.port_override = port_override if port_override is not None else 0
12845        '''
12846
12847        '''
12848        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12849        '''
12850         ID of the secret store containing credentials for this resource, if any.
12851        '''
12852        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12853        '''
12854         Tags is a map of key, value pairs.
12855        '''
12856        self.username = username if username is not None else ''
12857        '''
12858
12859        '''
12860
12861    def __repr__(self):
12862        return '<sdm.Teradata ' + \
12863            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12864            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12865            'healthy: ' + repr(self.healthy) + ' ' +\
12866            'hostname: ' + repr(self.hostname) + ' ' +\
12867            'id: ' + repr(self.id) + ' ' +\
12868            'name: ' + repr(self.name) + ' ' +\
12869            'password: ' + repr(self.password) + ' ' +\
12870            'port: ' + repr(self.port) + ' ' +\
12871            'port_override: ' + repr(self.port_override) + ' ' +\
12872            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12873            'tags: ' + repr(self.tags) + ' ' +\
12874            'username: ' + repr(self.username) + ' ' +\
12875            '>'
12876
12877    def to_dict(self):
12878        return {
12879            'bind_interface': self.bind_interface,
12880            'egress_filter': self.egress_filter,
12881            'healthy': self.healthy,
12882            'hostname': self.hostname,
12883            'id': self.id,
12884            'name': self.name,
12885            'password': self.password,
12886            'port': self.port,
12887            'port_override': self.port_override,
12888            'secret_store_id': self.secret_store_id,
12889            'tags': self.tags,
12890            'username': self.username,
12891        }
12892
12893    @classmethod
12894    def from_dict(cls, d):
12895        return cls(
12896            bind_interface=d.get('bind_interface'),
12897            egress_filter=d.get('egress_filter'),
12898            healthy=d.get('healthy'),
12899            hostname=d.get('hostname'),
12900            id=d.get('id'),
12901            name=d.get('name'),
12902            password=d.get('password'),
12903            port=d.get('port'),
12904            port_override=d.get('port_override'),
12905            secret_store_id=d.get('secret_store_id'),
12906            tags=d.get('tags'),
12907            username=d.get('username'),
12908        )
12909
12910
12911class UpdateResponseMetadata:
12912    '''
12913     UpdateResponseMetadata is reserved for future use.
12914    '''
12915    __slots__ = []
12916
12917    def __init__(self, ):
12918        pass
12919
12920    def __repr__(self):
12921        return '<sdm.UpdateResponseMetadata ' + \
12922            '>'
12923
12924    def to_dict(self):
12925        return {}
12926
12927    @classmethod
12928    def from_dict(cls, d):
12929        return cls()
12930
12931
12932class User:
12933    '''
12934     A User can connect to resources they are granted directly, or granted
12935     via roles.
12936    '''
12937    __slots__ = [
12938        'email',
12939        'first_name',
12940        'id',
12941        'last_name',
12942        'suspended',
12943        'tags',
12944    ]
12945
12946    def __init__(
12947        self,
12948        email=None,
12949        first_name=None,
12950        id=None,
12951        last_name=None,
12952        suspended=None,
12953        tags=None,
12954    ):
12955        self.email = email if email is not None else ''
12956        '''
12957         The User's email address. Must be unique.
12958        '''
12959        self.first_name = first_name if first_name is not None else ''
12960        '''
12961         The User's first name.
12962        '''
12963        self.id = id if id is not None else ''
12964        '''
12965         Unique identifier of the User.
12966        '''
12967        self.last_name = last_name if last_name is not None else ''
12968        '''
12969         The User's last name.
12970        '''
12971        self.suspended = suspended if suspended is not None else False
12972        '''
12973         The User's suspended state.
12974        '''
12975        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12976        '''
12977         Tags is a map of key, value pairs.
12978        '''
12979
12980    def __repr__(self):
12981        return '<sdm.User ' + \
12982            'email: ' + repr(self.email) + ' ' +\
12983            'first_name: ' + repr(self.first_name) + ' ' +\
12984            'id: ' + repr(self.id) + ' ' +\
12985            'last_name: ' + repr(self.last_name) + ' ' +\
12986            'suspended: ' + repr(self.suspended) + ' ' +\
12987            'tags: ' + repr(self.tags) + ' ' +\
12988            '>'
12989
12990    def to_dict(self):
12991        return {
12992            'email': self.email,
12993            'first_name': self.first_name,
12994            'id': self.id,
12995            'last_name': self.last_name,
12996            'suspended': self.suspended,
12997            'tags': self.tags,
12998        }
12999
13000    @classmethod
13001    def from_dict(cls, d):
13002        return cls(
13003            email=d.get('email'),
13004            first_name=d.get('first_name'),
13005            id=d.get('id'),
13006            last_name=d.get('last_name'),
13007            suspended=d.get('suspended'),
13008            tags=d.get('tags'),
13009        )
13010
13011
13012class VaultAppRoleStore:
13013    '''
13014
13015    '''
13016    __slots__ = [
13017        'id',
13018        'name',
13019        'namespace',
13020        'server_address',
13021        'tags',
13022    ]
13023
13024    def __init__(
13025        self,
13026        id=None,
13027        name=None,
13028        namespace=None,
13029        server_address=None,
13030        tags=None,
13031    ):
13032        self.id = id if id is not None else ''
13033        '''
13034         Unique identifier of the SecretStore.
13035        '''
13036        self.name = name if name is not None else ''
13037        '''
13038         Unique human-readable name of the SecretStore.
13039        '''
13040        self.namespace = namespace if namespace is not None else ''
13041        '''
13042
13043        '''
13044        self.server_address = server_address if server_address is not None else ''
13045        '''
13046
13047        '''
13048        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13049        '''
13050         Tags is a map of key, value pairs.
13051        '''
13052
13053    def __repr__(self):
13054        return '<sdm.VaultAppRoleStore ' + \
13055            'id: ' + repr(self.id) + ' ' +\
13056            'name: ' + repr(self.name) + ' ' +\
13057            'namespace: ' + repr(self.namespace) + ' ' +\
13058            'server_address: ' + repr(self.server_address) + ' ' +\
13059            'tags: ' + repr(self.tags) + ' ' +\
13060            '>'
13061
13062    def to_dict(self):
13063        return {
13064            'id': self.id,
13065            'name': self.name,
13066            'namespace': self.namespace,
13067            'server_address': self.server_address,
13068            'tags': self.tags,
13069        }
13070
13071    @classmethod
13072    def from_dict(cls, d):
13073        return cls(
13074            id=d.get('id'),
13075            name=d.get('name'),
13076            namespace=d.get('namespace'),
13077            server_address=d.get('server_address'),
13078            tags=d.get('tags'),
13079        )
13080
13081
13082class VaultTLSStore:
13083    '''
13084
13085    '''
13086    __slots__ = [
13087        'ca_cert_path',
13088        'client_cert_path',
13089        'client_key_path',
13090        'id',
13091        'name',
13092        'namespace',
13093        'server_address',
13094        'tags',
13095    ]
13096
13097    def __init__(
13098        self,
13099        ca_cert_path=None,
13100        client_cert_path=None,
13101        client_key_path=None,
13102        id=None,
13103        name=None,
13104        namespace=None,
13105        server_address=None,
13106        tags=None,
13107    ):
13108        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
13109        '''
13110
13111        '''
13112        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
13113        '''
13114
13115        '''
13116        self.client_key_path = client_key_path if client_key_path is not None else ''
13117        '''
13118
13119        '''
13120        self.id = id if id is not None else ''
13121        '''
13122         Unique identifier of the SecretStore.
13123        '''
13124        self.name = name if name is not None else ''
13125        '''
13126         Unique human-readable name of the SecretStore.
13127        '''
13128        self.namespace = namespace if namespace is not None else ''
13129        '''
13130
13131        '''
13132        self.server_address = server_address if server_address is not None else ''
13133        '''
13134
13135        '''
13136        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13137        '''
13138         Tags is a map of key, value pairs.
13139        '''
13140
13141    def __repr__(self):
13142        return '<sdm.VaultTLSStore ' + \
13143            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
13144            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
13145            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
13146            'id: ' + repr(self.id) + ' ' +\
13147            'name: ' + repr(self.name) + ' ' +\
13148            'namespace: ' + repr(self.namespace) + ' ' +\
13149            'server_address: ' + repr(self.server_address) + ' ' +\
13150            'tags: ' + repr(self.tags) + ' ' +\
13151            '>'
13152
13153    def to_dict(self):
13154        return {
13155            'ca_cert_path': self.ca_cert_path,
13156            'client_cert_path': self.client_cert_path,
13157            'client_key_path': self.client_key_path,
13158            'id': self.id,
13159            'name': self.name,
13160            'namespace': self.namespace,
13161            'server_address': self.server_address,
13162            'tags': self.tags,
13163        }
13164
13165    @classmethod
13166    def from_dict(cls, d):
13167        return cls(
13168            ca_cert_path=d.get('ca_cert_path'),
13169            client_cert_path=d.get('client_cert_path'),
13170            client_key_path=d.get('client_key_path'),
13171            id=d.get('id'),
13172            name=d.get('name'),
13173            namespace=d.get('namespace'),
13174            server_address=d.get('server_address'),
13175            tags=d.get('tags'),
13176        )
13177
13178
13179class VaultTokenStore:
13180    '''
13181
13182    '''
13183    __slots__ = [
13184        'id',
13185        'name',
13186        'namespace',
13187        'server_address',
13188        'tags',
13189    ]
13190
13191    def __init__(
13192        self,
13193        id=None,
13194        name=None,
13195        namespace=None,
13196        server_address=None,
13197        tags=None,
13198    ):
13199        self.id = id if id is not None else ''
13200        '''
13201         Unique identifier of the SecretStore.
13202        '''
13203        self.name = name if name is not None else ''
13204        '''
13205         Unique human-readable name of the SecretStore.
13206        '''
13207        self.namespace = namespace if namespace is not None else ''
13208        '''
13209
13210        '''
13211        self.server_address = server_address if server_address is not None else ''
13212        '''
13213
13214        '''
13215        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13216        '''
13217         Tags is a map of key, value pairs.
13218        '''
13219
13220    def __repr__(self):
13221        return '<sdm.VaultTokenStore ' + \
13222            'id: ' + repr(self.id) + ' ' +\
13223            'name: ' + repr(self.name) + ' ' +\
13224            'namespace: ' + repr(self.namespace) + ' ' +\
13225            'server_address: ' + repr(self.server_address) + ' ' +\
13226            'tags: ' + repr(self.tags) + ' ' +\
13227            '>'
13228
13229    def to_dict(self):
13230        return {
13231            'id': self.id,
13232            'name': self.name,
13233            'namespace': self.namespace,
13234            'server_address': self.server_address,
13235            'tags': self.tags,
13236        }
13237
13238    @classmethod
13239    def from_dict(cls, d):
13240        return cls(
13241            id=d.get('id'),
13242            name=d.get('name'),
13243            namespace=d.get('namespace'),
13244            server_address=d.get('server_address'),
13245            tags=d.get('tags'),
13246        )
13247
13248
13249def _porcelain_zero_value_tags():
13250    return {}
13251
13252
13253def _porcelain_zero_value_access_rules():
13254    return []
class AKS:
 22class AKS:
 23    '''
 24
 25    '''
 26    __slots__ = [
 27        'bind_interface',
 28        'certificate_authority',
 29        'client_certificate',
 30        'client_key',
 31        'egress_filter',
 32        'healthcheck_namespace',
 33        'healthy',
 34        'hostname',
 35        'id',
 36        'name',
 37        'port',
 38        'port_override',
 39        'remote_identity_group_id',
 40        'remote_identity_healthcheck_username',
 41        'secret_store_id',
 42        'tags',
 43    ]
 44
 45    def __init__(
 46        self,
 47        bind_interface=None,
 48        certificate_authority=None,
 49        client_certificate=None,
 50        client_key=None,
 51        egress_filter=None,
 52        healthcheck_namespace=None,
 53        healthy=None,
 54        hostname=None,
 55        id=None,
 56        name=None,
 57        port=None,
 58        port_override=None,
 59        remote_identity_group_id=None,
 60        remote_identity_healthcheck_username=None,
 61        secret_store_id=None,
 62        tags=None,
 63    ):
 64        self.bind_interface = bind_interface if bind_interface is not None else ''
 65        '''
 66         Bind interface
 67        '''
 68        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 69        '''
 70
 71        '''
 72        self.client_certificate = client_certificate if client_certificate is not None else ''
 73        '''
 74
 75        '''
 76        self.client_key = client_key if client_key is not None else ''
 77        '''
 78
 79        '''
 80        self.egress_filter = egress_filter if egress_filter is not None else ''
 81        '''
 82         A filter applied to the routing logic to pin datasource to nodes.
 83        '''
 84        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 85        '''
 86         The path used to check the health of your connection.  Defaults to `default`.
 87        '''
 88        self.healthy = healthy if healthy is not None else False
 89        '''
 90         True if the datasource is reachable and the credentials are valid.
 91        '''
 92        self.hostname = hostname if hostname is not None else ''
 93        '''
 94
 95        '''
 96        self.id = id if id is not None else ''
 97        '''
 98         Unique identifier of the Resource.
 99        '''
100        self.name = name if name is not None else ''
101        '''
102         Unique human-readable name of the Resource.
103        '''
104        self.port = port if port is not None else 0
105        '''
106
107        '''
108        self.port_override = port_override if port_override is not None else 0
109        '''
110
111        '''
112        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
113        '''
114
115        '''
116        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
117        '''
118
119        '''
120        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
121        '''
122         ID of the secret store containing credentials for this resource, if any.
123        '''
124        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
125        '''
126         Tags is a map of key, value pairs.
127        '''
128
129    def __repr__(self):
130        return '<sdm.AKS ' + \
131            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
132            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
133            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
134            'client_key: ' + repr(self.client_key) + ' ' +\
135            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
136            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
137            'healthy: ' + repr(self.healthy) + ' ' +\
138            'hostname: ' + repr(self.hostname) + ' ' +\
139            'id: ' + repr(self.id) + ' ' +\
140            'name: ' + repr(self.name) + ' ' +\
141            'port: ' + repr(self.port) + ' ' +\
142            'port_override: ' + repr(self.port_override) + ' ' +\
143            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
144            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
145            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
146            'tags: ' + repr(self.tags) + ' ' +\
147            '>'
148
149    def to_dict(self):
150        return {
151            'bind_interface': self.bind_interface,
152            'certificate_authority': self.certificate_authority,
153            'client_certificate': self.client_certificate,
154            'client_key': self.client_key,
155            'egress_filter': self.egress_filter,
156            'healthcheck_namespace': self.healthcheck_namespace,
157            'healthy': self.healthy,
158            'hostname': self.hostname,
159            'id': self.id,
160            'name': self.name,
161            'port': self.port,
162            'port_override': self.port_override,
163            'remote_identity_group_id': self.remote_identity_group_id,
164            'remote_identity_healthcheck_username':
165            self.remote_identity_healthcheck_username,
166            'secret_store_id': self.secret_store_id,
167            'tags': self.tags,
168        }
169
170    @classmethod
171    def from_dict(cls, d):
172        return cls(
173            bind_interface=d.get('bind_interface'),
174            certificate_authority=d.get('certificate_authority'),
175            client_certificate=d.get('client_certificate'),
176            client_key=d.get('client_key'),
177            egress_filter=d.get('egress_filter'),
178            healthcheck_namespace=d.get('healthcheck_namespace'),
179            healthy=d.get('healthy'),
180            hostname=d.get('hostname'),
181            id=d.get('id'),
182            name=d.get('name'),
183            port=d.get('port'),
184            port_override=d.get('port_override'),
185            remote_identity_group_id=d.get('remote_identity_group_id'),
186            remote_identity_healthcheck_username=d.get(
187                'remote_identity_healthcheck_username'),
188            secret_store_id=d.get('secret_store_id'),
189            tags=d.get('tags'),
190        )
AKS( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
 45    def __init__(
 46        self,
 47        bind_interface=None,
 48        certificate_authority=None,
 49        client_certificate=None,
 50        client_key=None,
 51        egress_filter=None,
 52        healthcheck_namespace=None,
 53        healthy=None,
 54        hostname=None,
 55        id=None,
 56        name=None,
 57        port=None,
 58        port_override=None,
 59        remote_identity_group_id=None,
 60        remote_identity_healthcheck_username=None,
 61        secret_store_id=None,
 62        tags=None,
 63    ):
 64        self.bind_interface = bind_interface if bind_interface is not None else ''
 65        '''
 66         Bind interface
 67        '''
 68        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 69        '''
 70
 71        '''
 72        self.client_certificate = client_certificate if client_certificate is not None else ''
 73        '''
 74
 75        '''
 76        self.client_key = client_key if client_key is not None else ''
 77        '''
 78
 79        '''
 80        self.egress_filter = egress_filter if egress_filter is not None else ''
 81        '''
 82         A filter applied to the routing logic to pin datasource to nodes.
 83        '''
 84        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 85        '''
 86         The path used to check the health of your connection.  Defaults to `default`.
 87        '''
 88        self.healthy = healthy if healthy is not None else False
 89        '''
 90         True if the datasource is reachable and the credentials are valid.
 91        '''
 92        self.hostname = hostname if hostname is not None else ''
 93        '''
 94
 95        '''
 96        self.id = id if id is not None else ''
 97        '''
 98         Unique identifier of the Resource.
 99        '''
100        self.name = name if name is not None else ''
101        '''
102         Unique human-readable name of the Resource.
103        '''
104        self.port = port if port is not None else 0
105        '''
106
107        '''
108        self.port_override = port_override if port_override is not None else 0
109        '''
110
111        '''
112        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
113        '''
114
115        '''
116        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
117        '''
118
119        '''
120        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
121        '''
122         ID of the secret store containing credentials for this resource, if any.
123        '''
124        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
125        '''
126         Tags is a map of key, value pairs.
127        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
149    def to_dict(self):
150        return {
151            'bind_interface': self.bind_interface,
152            'certificate_authority': self.certificate_authority,
153            'client_certificate': self.client_certificate,
154            'client_key': self.client_key,
155            'egress_filter': self.egress_filter,
156            'healthcheck_namespace': self.healthcheck_namespace,
157            'healthy': self.healthy,
158            'hostname': self.hostname,
159            'id': self.id,
160            'name': self.name,
161            'port': self.port,
162            'port_override': self.port_override,
163            'remote_identity_group_id': self.remote_identity_group_id,
164            'remote_identity_healthcheck_username':
165            self.remote_identity_healthcheck_username,
166            'secret_store_id': self.secret_store_id,
167            'tags': self.tags,
168        }
@classmethod
def from_dict(cls, d)
170    @classmethod
171    def from_dict(cls, d):
172        return cls(
173            bind_interface=d.get('bind_interface'),
174            certificate_authority=d.get('certificate_authority'),
175            client_certificate=d.get('client_certificate'),
176            client_key=d.get('client_key'),
177            egress_filter=d.get('egress_filter'),
178            healthcheck_namespace=d.get('healthcheck_namespace'),
179            healthy=d.get('healthy'),
180            hostname=d.get('hostname'),
181            id=d.get('id'),
182            name=d.get('name'),
183            port=d.get('port'),
184            port_override=d.get('port_override'),
185            remote_identity_group_id=d.get('remote_identity_group_id'),
186            remote_identity_healthcheck_username=d.get(
187                'remote_identity_healthcheck_username'),
188            secret_store_id=d.get('secret_store_id'),
189            tags=d.get('tags'),
190        )
class AKSBasicAuth:
193class AKSBasicAuth:
194    '''
195
196    '''
197    __slots__ = [
198        'bind_interface',
199        'egress_filter',
200        'healthcheck_namespace',
201        'healthy',
202        'hostname',
203        'id',
204        'name',
205        'password',
206        'port',
207        'port_override',
208        'secret_store_id',
209        'tags',
210        'username',
211    ]
212
213    def __init__(
214        self,
215        bind_interface=None,
216        egress_filter=None,
217        healthcheck_namespace=None,
218        healthy=None,
219        hostname=None,
220        id=None,
221        name=None,
222        password=None,
223        port=None,
224        port_override=None,
225        secret_store_id=None,
226        tags=None,
227        username=None,
228    ):
229        self.bind_interface = bind_interface if bind_interface is not None else ''
230        '''
231         Bind interface
232        '''
233        self.egress_filter = egress_filter if egress_filter is not None else ''
234        '''
235         A filter applied to the routing logic to pin datasource to nodes.
236        '''
237        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
238        '''
239         The path used to check the health of your connection.  Defaults to `default`.
240        '''
241        self.healthy = healthy if healthy is not None else False
242        '''
243         True if the datasource is reachable and the credentials are valid.
244        '''
245        self.hostname = hostname if hostname is not None else ''
246        '''
247
248        '''
249        self.id = id if id is not None else ''
250        '''
251         Unique identifier of the Resource.
252        '''
253        self.name = name if name is not None else ''
254        '''
255         Unique human-readable name of the Resource.
256        '''
257        self.password = password if password is not None else ''
258        '''
259
260        '''
261        self.port = port if port is not None else 0
262        '''
263
264        '''
265        self.port_override = port_override if port_override is not None else 0
266        '''
267
268        '''
269        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
270        '''
271         ID of the secret store containing credentials for this resource, if any.
272        '''
273        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
274        '''
275         Tags is a map of key, value pairs.
276        '''
277        self.username = username if username is not None else ''
278        '''
279
280        '''
281
282    def __repr__(self):
283        return '<sdm.AKSBasicAuth ' + \
284            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
285            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
286            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
287            'healthy: ' + repr(self.healthy) + ' ' +\
288            'hostname: ' + repr(self.hostname) + ' ' +\
289            'id: ' + repr(self.id) + ' ' +\
290            'name: ' + repr(self.name) + ' ' +\
291            'password: ' + repr(self.password) + ' ' +\
292            'port: ' + repr(self.port) + ' ' +\
293            'port_override: ' + repr(self.port_override) + ' ' +\
294            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
295            'tags: ' + repr(self.tags) + ' ' +\
296            'username: ' + repr(self.username) + ' ' +\
297            '>'
298
299    def to_dict(self):
300        return {
301            'bind_interface': self.bind_interface,
302            'egress_filter': self.egress_filter,
303            'healthcheck_namespace': self.healthcheck_namespace,
304            'healthy': self.healthy,
305            'hostname': self.hostname,
306            'id': self.id,
307            'name': self.name,
308            'password': self.password,
309            'port': self.port,
310            'port_override': self.port_override,
311            'secret_store_id': self.secret_store_id,
312            'tags': self.tags,
313            'username': self.username,
314        }
315
316    @classmethod
317    def from_dict(cls, d):
318        return cls(
319            bind_interface=d.get('bind_interface'),
320            egress_filter=d.get('egress_filter'),
321            healthcheck_namespace=d.get('healthcheck_namespace'),
322            healthy=d.get('healthy'),
323            hostname=d.get('hostname'),
324            id=d.get('id'),
325            name=d.get('name'),
326            password=d.get('password'),
327            port=d.get('port'),
328            port_override=d.get('port_override'),
329            secret_store_id=d.get('secret_store_id'),
330            tags=d.get('tags'),
331            username=d.get('username'),
332        )
AKSBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
213    def __init__(
214        self,
215        bind_interface=None,
216        egress_filter=None,
217        healthcheck_namespace=None,
218        healthy=None,
219        hostname=None,
220        id=None,
221        name=None,
222        password=None,
223        port=None,
224        port_override=None,
225        secret_store_id=None,
226        tags=None,
227        username=None,
228    ):
229        self.bind_interface = bind_interface if bind_interface is not None else ''
230        '''
231         Bind interface
232        '''
233        self.egress_filter = egress_filter if egress_filter is not None else ''
234        '''
235         A filter applied to the routing logic to pin datasource to nodes.
236        '''
237        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
238        '''
239         The path used to check the health of your connection.  Defaults to `default`.
240        '''
241        self.healthy = healthy if healthy is not None else False
242        '''
243         True if the datasource is reachable and the credentials are valid.
244        '''
245        self.hostname = hostname if hostname is not None else ''
246        '''
247
248        '''
249        self.id = id if id is not None else ''
250        '''
251         Unique identifier of the Resource.
252        '''
253        self.name = name if name is not None else ''
254        '''
255         Unique human-readable name of the Resource.
256        '''
257        self.password = password if password is not None else ''
258        '''
259
260        '''
261        self.port = port if port is not None else 0
262        '''
263
264        '''
265        self.port_override = port_override if port_override is not None else 0
266        '''
267
268        '''
269        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
270        '''
271         ID of the secret store containing credentials for this resource, if any.
272        '''
273        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
274        '''
275         Tags is a map of key, value pairs.
276        '''
277        self.username = username if username is not None else ''
278        '''
279
280        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
299    def to_dict(self):
300        return {
301            'bind_interface': self.bind_interface,
302            'egress_filter': self.egress_filter,
303            'healthcheck_namespace': self.healthcheck_namespace,
304            'healthy': self.healthy,
305            'hostname': self.hostname,
306            'id': self.id,
307            'name': self.name,
308            'password': self.password,
309            'port': self.port,
310            'port_override': self.port_override,
311            'secret_store_id': self.secret_store_id,
312            'tags': self.tags,
313            'username': self.username,
314        }
@classmethod
def from_dict(cls, d)
316    @classmethod
317    def from_dict(cls, d):
318        return cls(
319            bind_interface=d.get('bind_interface'),
320            egress_filter=d.get('egress_filter'),
321            healthcheck_namespace=d.get('healthcheck_namespace'),
322            healthy=d.get('healthy'),
323            hostname=d.get('hostname'),
324            id=d.get('id'),
325            name=d.get('name'),
326            password=d.get('password'),
327            port=d.get('port'),
328            port_override=d.get('port_override'),
329            secret_store_id=d.get('secret_store_id'),
330            tags=d.get('tags'),
331            username=d.get('username'),
332        )
class AKSServiceAccount:
335class AKSServiceAccount:
336    '''
337
338    '''
339    __slots__ = [
340        'bind_interface',
341        'egress_filter',
342        'healthcheck_namespace',
343        'healthy',
344        'hostname',
345        'id',
346        'name',
347        'port',
348        'port_override',
349        'remote_identity_group_id',
350        'remote_identity_healthcheck_username',
351        'secret_store_id',
352        'tags',
353        'token',
354    ]
355
356    def __init__(
357        self,
358        bind_interface=None,
359        egress_filter=None,
360        healthcheck_namespace=None,
361        healthy=None,
362        hostname=None,
363        id=None,
364        name=None,
365        port=None,
366        port_override=None,
367        remote_identity_group_id=None,
368        remote_identity_healthcheck_username=None,
369        secret_store_id=None,
370        tags=None,
371        token=None,
372    ):
373        self.bind_interface = bind_interface if bind_interface is not None else ''
374        '''
375         Bind interface
376        '''
377        self.egress_filter = egress_filter if egress_filter is not None else ''
378        '''
379         A filter applied to the routing logic to pin datasource to nodes.
380        '''
381        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
382        '''
383         The path used to check the health of your connection.  Defaults to `default`.
384        '''
385        self.healthy = healthy if healthy is not None else False
386        '''
387         True if the datasource is reachable and the credentials are valid.
388        '''
389        self.hostname = hostname if hostname is not None else ''
390        '''
391
392        '''
393        self.id = id if id is not None else ''
394        '''
395         Unique identifier of the Resource.
396        '''
397        self.name = name if name is not None else ''
398        '''
399         Unique human-readable name of the Resource.
400        '''
401        self.port = port if port is not None else 0
402        '''
403
404        '''
405        self.port_override = port_override if port_override is not None else 0
406        '''
407
408        '''
409        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
410        '''
411
412        '''
413        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
414        '''
415
416        '''
417        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
418        '''
419         ID of the secret store containing credentials for this resource, if any.
420        '''
421        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
422        '''
423         Tags is a map of key, value pairs.
424        '''
425        self.token = token if token is not None else ''
426        '''
427
428        '''
429
430    def __repr__(self):
431        return '<sdm.AKSServiceAccount ' + \
432            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
433            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
434            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
435            'healthy: ' + repr(self.healthy) + ' ' +\
436            'hostname: ' + repr(self.hostname) + ' ' +\
437            'id: ' + repr(self.id) + ' ' +\
438            'name: ' + repr(self.name) + ' ' +\
439            'port: ' + repr(self.port) + ' ' +\
440            'port_override: ' + repr(self.port_override) + ' ' +\
441            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
442            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
443            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
444            'tags: ' + repr(self.tags) + ' ' +\
445            'token: ' + repr(self.token) + ' ' +\
446            '>'
447
448    def to_dict(self):
449        return {
450            'bind_interface': self.bind_interface,
451            'egress_filter': self.egress_filter,
452            'healthcheck_namespace': self.healthcheck_namespace,
453            'healthy': self.healthy,
454            'hostname': self.hostname,
455            'id': self.id,
456            'name': self.name,
457            'port': self.port,
458            'port_override': self.port_override,
459            'remote_identity_group_id': self.remote_identity_group_id,
460            'remote_identity_healthcheck_username':
461            self.remote_identity_healthcheck_username,
462            'secret_store_id': self.secret_store_id,
463            'tags': self.tags,
464            'token': self.token,
465        }
466
467    @classmethod
468    def from_dict(cls, d):
469        return cls(
470            bind_interface=d.get('bind_interface'),
471            egress_filter=d.get('egress_filter'),
472            healthcheck_namespace=d.get('healthcheck_namespace'),
473            healthy=d.get('healthy'),
474            hostname=d.get('hostname'),
475            id=d.get('id'),
476            name=d.get('name'),
477            port=d.get('port'),
478            port_override=d.get('port_override'),
479            remote_identity_group_id=d.get('remote_identity_group_id'),
480            remote_identity_healthcheck_username=d.get(
481                'remote_identity_healthcheck_username'),
482            secret_store_id=d.get('secret_store_id'),
483            tags=d.get('tags'),
484            token=d.get('token'),
485        )
AKSServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
356    def __init__(
357        self,
358        bind_interface=None,
359        egress_filter=None,
360        healthcheck_namespace=None,
361        healthy=None,
362        hostname=None,
363        id=None,
364        name=None,
365        port=None,
366        port_override=None,
367        remote_identity_group_id=None,
368        remote_identity_healthcheck_username=None,
369        secret_store_id=None,
370        tags=None,
371        token=None,
372    ):
373        self.bind_interface = bind_interface if bind_interface is not None else ''
374        '''
375         Bind interface
376        '''
377        self.egress_filter = egress_filter if egress_filter is not None else ''
378        '''
379         A filter applied to the routing logic to pin datasource to nodes.
380        '''
381        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
382        '''
383         The path used to check the health of your connection.  Defaults to `default`.
384        '''
385        self.healthy = healthy if healthy is not None else False
386        '''
387         True if the datasource is reachable and the credentials are valid.
388        '''
389        self.hostname = hostname if hostname is not None else ''
390        '''
391
392        '''
393        self.id = id if id is not None else ''
394        '''
395         Unique identifier of the Resource.
396        '''
397        self.name = name if name is not None else ''
398        '''
399         Unique human-readable name of the Resource.
400        '''
401        self.port = port if port is not None else 0
402        '''
403
404        '''
405        self.port_override = port_override if port_override is not None else 0
406        '''
407
408        '''
409        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
410        '''
411
412        '''
413        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
414        '''
415
416        '''
417        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
418        '''
419         ID of the secret store containing credentials for this resource, if any.
420        '''
421        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
422        '''
423         Tags is a map of key, value pairs.
424        '''
425        self.token = token if token is not None else ''
426        '''
427
428        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
448    def to_dict(self):
449        return {
450            'bind_interface': self.bind_interface,
451            'egress_filter': self.egress_filter,
452            'healthcheck_namespace': self.healthcheck_namespace,
453            'healthy': self.healthy,
454            'hostname': self.hostname,
455            'id': self.id,
456            'name': self.name,
457            'port': self.port,
458            'port_override': self.port_override,
459            'remote_identity_group_id': self.remote_identity_group_id,
460            'remote_identity_healthcheck_username':
461            self.remote_identity_healthcheck_username,
462            'secret_store_id': self.secret_store_id,
463            'tags': self.tags,
464            'token': self.token,
465        }
@classmethod
def from_dict(cls, d)
467    @classmethod
468    def from_dict(cls, d):
469        return cls(
470            bind_interface=d.get('bind_interface'),
471            egress_filter=d.get('egress_filter'),
472            healthcheck_namespace=d.get('healthcheck_namespace'),
473            healthy=d.get('healthy'),
474            hostname=d.get('hostname'),
475            id=d.get('id'),
476            name=d.get('name'),
477            port=d.get('port'),
478            port_override=d.get('port_override'),
479            remote_identity_group_id=d.get('remote_identity_group_id'),
480            remote_identity_healthcheck_username=d.get(
481                'remote_identity_healthcheck_username'),
482            secret_store_id=d.get('secret_store_id'),
483            tags=d.get('tags'),
484            token=d.get('token'),
485        )
class AKSServiceAccountUserImpersonation:
488class AKSServiceAccountUserImpersonation:
489    '''
490
491    '''
492    __slots__ = [
493        'bind_interface',
494        'egress_filter',
495        'healthcheck_namespace',
496        'healthy',
497        'hostname',
498        'id',
499        'name',
500        'port',
501        'port_override',
502        'secret_store_id',
503        'tags',
504        'token',
505    ]
506
507    def __init__(
508        self,
509        bind_interface=None,
510        egress_filter=None,
511        healthcheck_namespace=None,
512        healthy=None,
513        hostname=None,
514        id=None,
515        name=None,
516        port=None,
517        port_override=None,
518        secret_store_id=None,
519        tags=None,
520        token=None,
521    ):
522        self.bind_interface = bind_interface if bind_interface is not None else ''
523        '''
524         Bind interface
525        '''
526        self.egress_filter = egress_filter if egress_filter is not None else ''
527        '''
528         A filter applied to the routing logic to pin datasource to nodes.
529        '''
530        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
531        '''
532         The path used to check the health of your connection.  Defaults to `default`.
533        '''
534        self.healthy = healthy if healthy is not None else False
535        '''
536         True if the datasource is reachable and the credentials are valid.
537        '''
538        self.hostname = hostname if hostname is not None else ''
539        '''
540
541        '''
542        self.id = id if id is not None else ''
543        '''
544         Unique identifier of the Resource.
545        '''
546        self.name = name if name is not None else ''
547        '''
548         Unique human-readable name of the Resource.
549        '''
550        self.port = port if port is not None else 0
551        '''
552
553        '''
554        self.port_override = port_override if port_override is not None else 0
555        '''
556
557        '''
558        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
559        '''
560         ID of the secret store containing credentials for this resource, if any.
561        '''
562        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
563        '''
564         Tags is a map of key, value pairs.
565        '''
566        self.token = token if token is not None else ''
567        '''
568
569        '''
570
571    def __repr__(self):
572        return '<sdm.AKSServiceAccountUserImpersonation ' + \
573            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
574            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
575            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
576            'healthy: ' + repr(self.healthy) + ' ' +\
577            'hostname: ' + repr(self.hostname) + ' ' +\
578            'id: ' + repr(self.id) + ' ' +\
579            'name: ' + repr(self.name) + ' ' +\
580            'port: ' + repr(self.port) + ' ' +\
581            'port_override: ' + repr(self.port_override) + ' ' +\
582            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
583            'tags: ' + repr(self.tags) + ' ' +\
584            'token: ' + repr(self.token) + ' ' +\
585            '>'
586
587    def to_dict(self):
588        return {
589            'bind_interface': self.bind_interface,
590            'egress_filter': self.egress_filter,
591            'healthcheck_namespace': self.healthcheck_namespace,
592            'healthy': self.healthy,
593            'hostname': self.hostname,
594            'id': self.id,
595            'name': self.name,
596            'port': self.port,
597            'port_override': self.port_override,
598            'secret_store_id': self.secret_store_id,
599            'tags': self.tags,
600            'token': self.token,
601        }
602
603    @classmethod
604    def from_dict(cls, d):
605        return cls(
606            bind_interface=d.get('bind_interface'),
607            egress_filter=d.get('egress_filter'),
608            healthcheck_namespace=d.get('healthcheck_namespace'),
609            healthy=d.get('healthy'),
610            hostname=d.get('hostname'),
611            id=d.get('id'),
612            name=d.get('name'),
613            port=d.get('port'),
614            port_override=d.get('port_override'),
615            secret_store_id=d.get('secret_store_id'),
616            tags=d.get('tags'),
617            token=d.get('token'),
618        )
AKSServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None, token=None)
507    def __init__(
508        self,
509        bind_interface=None,
510        egress_filter=None,
511        healthcheck_namespace=None,
512        healthy=None,
513        hostname=None,
514        id=None,
515        name=None,
516        port=None,
517        port_override=None,
518        secret_store_id=None,
519        tags=None,
520        token=None,
521    ):
522        self.bind_interface = bind_interface if bind_interface is not None else ''
523        '''
524         Bind interface
525        '''
526        self.egress_filter = egress_filter if egress_filter is not None else ''
527        '''
528         A filter applied to the routing logic to pin datasource to nodes.
529        '''
530        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
531        '''
532         The path used to check the health of your connection.  Defaults to `default`.
533        '''
534        self.healthy = healthy if healthy is not None else False
535        '''
536         True if the datasource is reachable and the credentials are valid.
537        '''
538        self.hostname = hostname if hostname is not None else ''
539        '''
540
541        '''
542        self.id = id if id is not None else ''
543        '''
544         Unique identifier of the Resource.
545        '''
546        self.name = name if name is not None else ''
547        '''
548         Unique human-readable name of the Resource.
549        '''
550        self.port = port if port is not None else 0
551        '''
552
553        '''
554        self.port_override = port_override if port_override is not None else 0
555        '''
556
557        '''
558        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
559        '''
560         ID of the secret store containing credentials for this resource, if any.
561        '''
562        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
563        '''
564         Tags is a map of key, value pairs.
565        '''
566        self.token = token if token is not None else ''
567        '''
568
569        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
587    def to_dict(self):
588        return {
589            'bind_interface': self.bind_interface,
590            'egress_filter': self.egress_filter,
591            'healthcheck_namespace': self.healthcheck_namespace,
592            'healthy': self.healthy,
593            'hostname': self.hostname,
594            'id': self.id,
595            'name': self.name,
596            'port': self.port,
597            'port_override': self.port_override,
598            'secret_store_id': self.secret_store_id,
599            'tags': self.tags,
600            'token': self.token,
601        }
@classmethod
def from_dict(cls, d)
603    @classmethod
604    def from_dict(cls, d):
605        return cls(
606            bind_interface=d.get('bind_interface'),
607            egress_filter=d.get('egress_filter'),
608            healthcheck_namespace=d.get('healthcheck_namespace'),
609            healthy=d.get('healthy'),
610            hostname=d.get('hostname'),
611            id=d.get('id'),
612            name=d.get('name'),
613            port=d.get('port'),
614            port_override=d.get('port_override'),
615            secret_store_id=d.get('secret_store_id'),
616            tags=d.get('tags'),
617            token=d.get('token'),
618        )
class AKSUserImpersonation:
621class AKSUserImpersonation:
622    '''
623
624    '''
625    __slots__ = [
626        'bind_interface',
627        'certificate_authority',
628        'client_certificate',
629        'client_key',
630        'egress_filter',
631        'healthcheck_namespace',
632        'healthy',
633        'hostname',
634        'id',
635        'name',
636        'port',
637        'port_override',
638        'secret_store_id',
639        'tags',
640    ]
641
642    def __init__(
643        self,
644        bind_interface=None,
645        certificate_authority=None,
646        client_certificate=None,
647        client_key=None,
648        egress_filter=None,
649        healthcheck_namespace=None,
650        healthy=None,
651        hostname=None,
652        id=None,
653        name=None,
654        port=None,
655        port_override=None,
656        secret_store_id=None,
657        tags=None,
658    ):
659        self.bind_interface = bind_interface if bind_interface is not None else ''
660        '''
661         Bind interface
662        '''
663        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
664        '''
665
666        '''
667        self.client_certificate = client_certificate if client_certificate is not None else ''
668        '''
669
670        '''
671        self.client_key = client_key if client_key is not None else ''
672        '''
673
674        '''
675        self.egress_filter = egress_filter if egress_filter is not None else ''
676        '''
677         A filter applied to the routing logic to pin datasource to nodes.
678        '''
679        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
680        '''
681         The path used to check the health of your connection.  Defaults to `default`.
682        '''
683        self.healthy = healthy if healthy is not None else False
684        '''
685         True if the datasource is reachable and the credentials are valid.
686        '''
687        self.hostname = hostname if hostname is not None else ''
688        '''
689
690        '''
691        self.id = id if id is not None else ''
692        '''
693         Unique identifier of the Resource.
694        '''
695        self.name = name if name is not None else ''
696        '''
697         Unique human-readable name of the Resource.
698        '''
699        self.port = port if port is not None else 0
700        '''
701
702        '''
703        self.port_override = port_override if port_override is not None else 0
704        '''
705
706        '''
707        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
708        '''
709         ID of the secret store containing credentials for this resource, if any.
710        '''
711        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
712        '''
713         Tags is a map of key, value pairs.
714        '''
715
716    def __repr__(self):
717        return '<sdm.AKSUserImpersonation ' + \
718            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
719            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
720            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
721            'client_key: ' + repr(self.client_key) + ' ' +\
722            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
723            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
724            'healthy: ' + repr(self.healthy) + ' ' +\
725            'hostname: ' + repr(self.hostname) + ' ' +\
726            'id: ' + repr(self.id) + ' ' +\
727            'name: ' + repr(self.name) + ' ' +\
728            'port: ' + repr(self.port) + ' ' +\
729            'port_override: ' + repr(self.port_override) + ' ' +\
730            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
731            'tags: ' + repr(self.tags) + ' ' +\
732            '>'
733
734    def to_dict(self):
735        return {
736            'bind_interface': self.bind_interface,
737            'certificate_authority': self.certificate_authority,
738            'client_certificate': self.client_certificate,
739            'client_key': self.client_key,
740            'egress_filter': self.egress_filter,
741            'healthcheck_namespace': self.healthcheck_namespace,
742            'healthy': self.healthy,
743            'hostname': self.hostname,
744            'id': self.id,
745            'name': self.name,
746            'port': self.port,
747            'port_override': self.port_override,
748            'secret_store_id': self.secret_store_id,
749            'tags': self.tags,
750        }
751
752    @classmethod
753    def from_dict(cls, d):
754        return cls(
755            bind_interface=d.get('bind_interface'),
756            certificate_authority=d.get('certificate_authority'),
757            client_certificate=d.get('client_certificate'),
758            client_key=d.get('client_key'),
759            egress_filter=d.get('egress_filter'),
760            healthcheck_namespace=d.get('healthcheck_namespace'),
761            healthy=d.get('healthy'),
762            hostname=d.get('hostname'),
763            id=d.get('id'),
764            name=d.get('name'),
765            port=d.get('port'),
766            port_override=d.get('port_override'),
767            secret_store_id=d.get('secret_store_id'),
768            tags=d.get('tags'),
769        )
AKSUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
642    def __init__(
643        self,
644        bind_interface=None,
645        certificate_authority=None,
646        client_certificate=None,
647        client_key=None,
648        egress_filter=None,
649        healthcheck_namespace=None,
650        healthy=None,
651        hostname=None,
652        id=None,
653        name=None,
654        port=None,
655        port_override=None,
656        secret_store_id=None,
657        tags=None,
658    ):
659        self.bind_interface = bind_interface if bind_interface is not None else ''
660        '''
661         Bind interface
662        '''
663        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
664        '''
665
666        '''
667        self.client_certificate = client_certificate if client_certificate is not None else ''
668        '''
669
670        '''
671        self.client_key = client_key if client_key is not None else ''
672        '''
673
674        '''
675        self.egress_filter = egress_filter if egress_filter is not None else ''
676        '''
677         A filter applied to the routing logic to pin datasource to nodes.
678        '''
679        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
680        '''
681         The path used to check the health of your connection.  Defaults to `default`.
682        '''
683        self.healthy = healthy if healthy is not None else False
684        '''
685         True if the datasource is reachable and the credentials are valid.
686        '''
687        self.hostname = hostname if hostname is not None else ''
688        '''
689
690        '''
691        self.id = id if id is not None else ''
692        '''
693         Unique identifier of the Resource.
694        '''
695        self.name = name if name is not None else ''
696        '''
697         Unique human-readable name of the Resource.
698        '''
699        self.port = port if port is not None else 0
700        '''
701
702        '''
703        self.port_override = port_override if port_override is not None else 0
704        '''
705
706        '''
707        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
708        '''
709         ID of the secret store containing credentials for this resource, if any.
710        '''
711        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
712        '''
713         Tags is a map of key, value pairs.
714        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
734    def to_dict(self):
735        return {
736            'bind_interface': self.bind_interface,
737            'certificate_authority': self.certificate_authority,
738            'client_certificate': self.client_certificate,
739            'client_key': self.client_key,
740            'egress_filter': self.egress_filter,
741            'healthcheck_namespace': self.healthcheck_namespace,
742            'healthy': self.healthy,
743            'hostname': self.hostname,
744            'id': self.id,
745            'name': self.name,
746            'port': self.port,
747            'port_override': self.port_override,
748            'secret_store_id': self.secret_store_id,
749            'tags': self.tags,
750        }
@classmethod
def from_dict(cls, d)
752    @classmethod
753    def from_dict(cls, d):
754        return cls(
755            bind_interface=d.get('bind_interface'),
756            certificate_authority=d.get('certificate_authority'),
757            client_certificate=d.get('client_certificate'),
758            client_key=d.get('client_key'),
759            egress_filter=d.get('egress_filter'),
760            healthcheck_namespace=d.get('healthcheck_namespace'),
761            healthy=d.get('healthy'),
762            hostname=d.get('hostname'),
763            id=d.get('id'),
764            name=d.get('name'),
765            port=d.get('port'),
766            port_override=d.get('port_override'),
767            secret_store_id=d.get('secret_store_id'),
768            tags=d.get('tags'),
769        )
class AWS:
772class AWS:
773    '''
774
775    '''
776    __slots__ = [
777        'access_key',
778        'bind_interface',
779        'egress_filter',
780        'healthcheck_region',
781        'healthy',
782        'id',
783        'name',
784        'role_arn',
785        'role_external_id',
786        'secret_access_key',
787        'secret_store_id',
788        'tags',
789    ]
790
791    def __init__(
792        self,
793        access_key=None,
794        bind_interface=None,
795        egress_filter=None,
796        healthcheck_region=None,
797        healthy=None,
798        id=None,
799        name=None,
800        role_arn=None,
801        role_external_id=None,
802        secret_access_key=None,
803        secret_store_id=None,
804        tags=None,
805    ):
806        self.access_key = access_key if access_key is not None else ''
807        '''
808
809        '''
810        self.bind_interface = bind_interface if bind_interface is not None else ''
811        '''
812         Bind interface
813        '''
814        self.egress_filter = egress_filter if egress_filter is not None else ''
815        '''
816         A filter applied to the routing logic to pin datasource to nodes.
817        '''
818        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
819        '''
820
821        '''
822        self.healthy = healthy if healthy is not None else False
823        '''
824         True if the datasource is reachable and the credentials are valid.
825        '''
826        self.id = id if id is not None else ''
827        '''
828         Unique identifier of the Resource.
829        '''
830        self.name = name if name is not None else ''
831        '''
832         Unique human-readable name of the Resource.
833        '''
834        self.role_arn = role_arn if role_arn is not None else ''
835        '''
836
837        '''
838        self.role_external_id = role_external_id if role_external_id is not None else ''
839        '''
840
841        '''
842        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
843        '''
844
845        '''
846        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
847        '''
848         ID of the secret store containing credentials for this resource, if any.
849        '''
850        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
851        '''
852         Tags is a map of key, value pairs.
853        '''
854
855    def __repr__(self):
856        return '<sdm.AWS ' + \
857            'access_key: ' + repr(self.access_key) + ' ' +\
858            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
859            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
860            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
861            'healthy: ' + repr(self.healthy) + ' ' +\
862            'id: ' + repr(self.id) + ' ' +\
863            'name: ' + repr(self.name) + ' ' +\
864            'role_arn: ' + repr(self.role_arn) + ' ' +\
865            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
866            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
867            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
868            'tags: ' + repr(self.tags) + ' ' +\
869            '>'
870
871    def to_dict(self):
872        return {
873            'access_key': self.access_key,
874            'bind_interface': self.bind_interface,
875            'egress_filter': self.egress_filter,
876            'healthcheck_region': self.healthcheck_region,
877            'healthy': self.healthy,
878            'id': self.id,
879            'name': self.name,
880            'role_arn': self.role_arn,
881            'role_external_id': self.role_external_id,
882            'secret_access_key': self.secret_access_key,
883            'secret_store_id': self.secret_store_id,
884            'tags': self.tags,
885        }
886
887    @classmethod
888    def from_dict(cls, d):
889        return cls(
890            access_key=d.get('access_key'),
891            bind_interface=d.get('bind_interface'),
892            egress_filter=d.get('egress_filter'),
893            healthcheck_region=d.get('healthcheck_region'),
894            healthy=d.get('healthy'),
895            id=d.get('id'),
896            name=d.get('name'),
897            role_arn=d.get('role_arn'),
898            role_external_id=d.get('role_external_id'),
899            secret_access_key=d.get('secret_access_key'),
900            secret_store_id=d.get('secret_store_id'),
901            tags=d.get('tags'),
902        )
AWS( access_key=None, bind_interface=None, egress_filter=None, healthcheck_region=None, healthy=None, id=None, name=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
791    def __init__(
792        self,
793        access_key=None,
794        bind_interface=None,
795        egress_filter=None,
796        healthcheck_region=None,
797        healthy=None,
798        id=None,
799        name=None,
800        role_arn=None,
801        role_external_id=None,
802        secret_access_key=None,
803        secret_store_id=None,
804        tags=None,
805    ):
806        self.access_key = access_key if access_key is not None else ''
807        '''
808
809        '''
810        self.bind_interface = bind_interface if bind_interface is not None else ''
811        '''
812         Bind interface
813        '''
814        self.egress_filter = egress_filter if egress_filter is not None else ''
815        '''
816         A filter applied to the routing logic to pin datasource to nodes.
817        '''
818        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
819        '''
820
821        '''
822        self.healthy = healthy if healthy is not None else False
823        '''
824         True if the datasource is reachable and the credentials are valid.
825        '''
826        self.id = id if id is not None else ''
827        '''
828         Unique identifier of the Resource.
829        '''
830        self.name = name if name is not None else ''
831        '''
832         Unique human-readable name of the Resource.
833        '''
834        self.role_arn = role_arn if role_arn is not None else ''
835        '''
836
837        '''
838        self.role_external_id = role_external_id if role_external_id is not None else ''
839        '''
840
841        '''
842        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
843        '''
844
845        '''
846        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
847        '''
848         ID of the secret store containing credentials for this resource, if any.
849        '''
850        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
851        '''
852         Tags is a map of key, value pairs.
853        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_region
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
871    def to_dict(self):
872        return {
873            'access_key': self.access_key,
874            'bind_interface': self.bind_interface,
875            'egress_filter': self.egress_filter,
876            'healthcheck_region': self.healthcheck_region,
877            'healthy': self.healthy,
878            'id': self.id,
879            'name': self.name,
880            'role_arn': self.role_arn,
881            'role_external_id': self.role_external_id,
882            'secret_access_key': self.secret_access_key,
883            'secret_store_id': self.secret_store_id,
884            'tags': self.tags,
885        }
@classmethod
def from_dict(cls, d)
887    @classmethod
888    def from_dict(cls, d):
889        return cls(
890            access_key=d.get('access_key'),
891            bind_interface=d.get('bind_interface'),
892            egress_filter=d.get('egress_filter'),
893            healthcheck_region=d.get('healthcheck_region'),
894            healthy=d.get('healthy'),
895            id=d.get('id'),
896            name=d.get('name'),
897            role_arn=d.get('role_arn'),
898            role_external_id=d.get('role_external_id'),
899            secret_access_key=d.get('secret_access_key'),
900            secret_store_id=d.get('secret_store_id'),
901            tags=d.get('tags'),
902        )
class AWSStore:
905class AWSStore:
906    '''
907
908    '''
909    __slots__ = [
910        'id',
911        'name',
912        'region',
913        'tags',
914    ]
915
916    def __init__(
917        self,
918        id=None,
919        name=None,
920        region=None,
921        tags=None,
922    ):
923        self.id = id if id is not None else ''
924        '''
925         Unique identifier of the SecretStore.
926        '''
927        self.name = name if name is not None else ''
928        '''
929         Unique human-readable name of the SecretStore.
930        '''
931        self.region = region if region is not None else ''
932        '''
933
934        '''
935        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
936        '''
937         Tags is a map of key, value pairs.
938        '''
939
940    def __repr__(self):
941        return '<sdm.AWSStore ' + \
942            'id: ' + repr(self.id) + ' ' +\
943            'name: ' + repr(self.name) + ' ' +\
944            'region: ' + repr(self.region) + ' ' +\
945            'tags: ' + repr(self.tags) + ' ' +\
946            '>'
947
948    def to_dict(self):
949        return {
950            'id': self.id,
951            'name': self.name,
952            'region': self.region,
953            'tags': self.tags,
954        }
955
956    @classmethod
957    def from_dict(cls, d):
958        return cls(
959            id=d.get('id'),
960            name=d.get('name'),
961            region=d.get('region'),
962            tags=d.get('tags'),
963        )
AWSStore(id=None, name=None, region=None, tags=None)
916    def __init__(
917        self,
918        id=None,
919        name=None,
920        region=None,
921        tags=None,
922    ):
923        self.id = id if id is not None else ''
924        '''
925         Unique identifier of the SecretStore.
926        '''
927        self.name = name if name is not None else ''
928        '''
929         Unique human-readable name of the SecretStore.
930        '''
931        self.region = region if region is not None else ''
932        '''
933
934        '''
935        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
936        '''
937         Tags is a map of key, value pairs.
938        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

region
tags

Tags is a map of key, value pairs.

def to_dict(self)
948    def to_dict(self):
949        return {
950            'id': self.id,
951            'name': self.name,
952            'region': self.region,
953            'tags': self.tags,
954        }
@classmethod
def from_dict(cls, d)
956    @classmethod
957    def from_dict(cls, d):
958        return cls(
959            id=d.get('id'),
960            name=d.get('name'),
961            region=d.get('region'),
962            tags=d.get('tags'),
963        )
class AccountAttachment:
 966class AccountAttachment:
 967    '''
 968     AccountAttachments assign an account to a role.
 969    '''
 970    __slots__ = [
 971        'account_id',
 972        'id',
 973        'role_id',
 974    ]
 975
 976    def __init__(
 977        self,
 978        account_id=None,
 979        id=None,
 980        role_id=None,
 981    ):
 982        self.account_id = account_id if account_id is not None else ''
 983        '''
 984         The id of the account of this AccountAttachment.
 985        '''
 986        self.id = id if id is not None else ''
 987        '''
 988         Unique identifier of the AccountAttachment.
 989        '''
 990        self.role_id = role_id if role_id is not None else ''
 991        '''
 992         The id of the attached role of this AccountAttachment.
 993        '''
 994
 995    def __repr__(self):
 996        return '<sdm.AccountAttachment ' + \
 997            'account_id: ' + repr(self.account_id) + ' ' +\
 998            'id: ' + repr(self.id) + ' ' +\
 999            'role_id: ' + repr(self.role_id) + ' ' +\
1000            '>'
1001
1002    def to_dict(self):
1003        return {
1004            'account_id': self.account_id,
1005            'id': self.id,
1006            'role_id': self.role_id,
1007        }
1008
1009    @classmethod
1010    def from_dict(cls, d):
1011        return cls(
1012            account_id=d.get('account_id'),
1013            id=d.get('id'),
1014            role_id=d.get('role_id'),
1015        )

AccountAttachments assign an account to a role.

AccountAttachment(account_id=None, id=None, role_id=None)
976    def __init__(
977        self,
978        account_id=None,
979        id=None,
980        role_id=None,
981    ):
982        self.account_id = account_id if account_id is not None else ''
983        '''
984         The id of the account of this AccountAttachment.
985        '''
986        self.id = id if id is not None else ''
987        '''
988         Unique identifier of the AccountAttachment.
989        '''
990        self.role_id = role_id if role_id is not None else ''
991        '''
992         The id of the attached role of this AccountAttachment.
993        '''
account_id

The id of the account of this AccountAttachment.

id

Unique identifier of the AccountAttachment.

role_id

The id of the attached role of this AccountAttachment.

def to_dict(self)
1002    def to_dict(self):
1003        return {
1004            'account_id': self.account_id,
1005            'id': self.id,
1006            'role_id': self.role_id,
1007        }
@classmethod
def from_dict(cls, d)
1009    @classmethod
1010    def from_dict(cls, d):
1011        return cls(
1012            account_id=d.get('account_id'),
1013            id=d.get('id'),
1014            role_id=d.get('role_id'),
1015        )
class AccountAttachmentCreateResponse:
1018class AccountAttachmentCreateResponse:
1019    '''
1020     AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
1021    '''
1022    __slots__ = [
1023        'account_attachment',
1024        'meta',
1025        'rate_limit',
1026    ]
1027
1028    def __init__(
1029        self,
1030        account_attachment=None,
1031        meta=None,
1032        rate_limit=None,
1033    ):
1034        self.account_attachment = account_attachment if account_attachment is not None else None
1035        '''
1036         The created AccountAttachment.
1037        '''
1038        self.meta = meta if meta is not None else None
1039        '''
1040         Reserved for future use.
1041        '''
1042        self.rate_limit = rate_limit if rate_limit is not None else None
1043        '''
1044         Rate limit information.
1045        '''
1046
1047    def __repr__(self):
1048        return '<sdm.AccountAttachmentCreateResponse ' + \
1049            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1050            'meta: ' + repr(self.meta) + ' ' +\
1051            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1052            '>'
1053
1054    def to_dict(self):
1055        return {
1056            'account_attachment': self.account_attachment,
1057            'meta': self.meta,
1058            'rate_limit': self.rate_limit,
1059        }
1060
1061    @classmethod
1062    def from_dict(cls, d):
1063        return cls(
1064            account_attachment=d.get('account_attachment'),
1065            meta=d.get('meta'),
1066            rate_limit=d.get('rate_limit'),
1067        )

AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.

AccountAttachmentCreateResponse(account_attachment=None, meta=None, rate_limit=None)
1028    def __init__(
1029        self,
1030        account_attachment=None,
1031        meta=None,
1032        rate_limit=None,
1033    ):
1034        self.account_attachment = account_attachment if account_attachment is not None else None
1035        '''
1036         The created AccountAttachment.
1037        '''
1038        self.meta = meta if meta is not None else None
1039        '''
1040         Reserved for future use.
1041        '''
1042        self.rate_limit = rate_limit if rate_limit is not None else None
1043        '''
1044         Rate limit information.
1045        '''
account_attachment

The created AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1054    def to_dict(self):
1055        return {
1056            'account_attachment': self.account_attachment,
1057            'meta': self.meta,
1058            'rate_limit': self.rate_limit,
1059        }
@classmethod
def from_dict(cls, d)
1061    @classmethod
1062    def from_dict(cls, d):
1063        return cls(
1064            account_attachment=d.get('account_attachment'),
1065            meta=d.get('meta'),
1066            rate_limit=d.get('rate_limit'),
1067        )
class AccountAttachmentDeleteResponse:
1070class AccountAttachmentDeleteResponse:
1071    '''
1072     AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
1073    '''
1074    __slots__ = [
1075        'meta',
1076        'rate_limit',
1077    ]
1078
1079    def __init__(
1080        self,
1081        meta=None,
1082        rate_limit=None,
1083    ):
1084        self.meta = meta if meta is not None else None
1085        '''
1086         Reserved for future use.
1087        '''
1088        self.rate_limit = rate_limit if rate_limit is not None else None
1089        '''
1090         Rate limit information.
1091        '''
1092
1093    def __repr__(self):
1094        return '<sdm.AccountAttachmentDeleteResponse ' + \
1095            'meta: ' + repr(self.meta) + ' ' +\
1096            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1097            '>'
1098
1099    def to_dict(self):
1100        return {
1101            'meta': self.meta,
1102            'rate_limit': self.rate_limit,
1103        }
1104
1105    @classmethod
1106    def from_dict(cls, d):
1107        return cls(
1108            meta=d.get('meta'),
1109            rate_limit=d.get('rate_limit'),
1110        )

AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.

AccountAttachmentDeleteResponse(meta=None, rate_limit=None)
1079    def __init__(
1080        self,
1081        meta=None,
1082        rate_limit=None,
1083    ):
1084        self.meta = meta if meta is not None else None
1085        '''
1086         Reserved for future use.
1087        '''
1088        self.rate_limit = rate_limit if rate_limit is not None else None
1089        '''
1090         Rate limit information.
1091        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1099    def to_dict(self):
1100        return {
1101            'meta': self.meta,
1102            'rate_limit': self.rate_limit,
1103        }
@classmethod
def from_dict(cls, d)
1105    @classmethod
1106    def from_dict(cls, d):
1107        return cls(
1108            meta=d.get('meta'),
1109            rate_limit=d.get('rate_limit'),
1110        )
class AccountAttachmentGetResponse:
1113class AccountAttachmentGetResponse:
1114    '''
1115     AccountAttachmentGetResponse returns a requested AccountAttachment.
1116    '''
1117    __slots__ = [
1118        'account_attachment',
1119        'meta',
1120        'rate_limit',
1121    ]
1122
1123    def __init__(
1124        self,
1125        account_attachment=None,
1126        meta=None,
1127        rate_limit=None,
1128    ):
1129        self.account_attachment = account_attachment if account_attachment is not None else None
1130        '''
1131         The requested AccountAttachment.
1132        '''
1133        self.meta = meta if meta is not None else None
1134        '''
1135         Reserved for future use.
1136        '''
1137        self.rate_limit = rate_limit if rate_limit is not None else None
1138        '''
1139         Rate limit information.
1140        '''
1141
1142    def __repr__(self):
1143        return '<sdm.AccountAttachmentGetResponse ' + \
1144            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1145            'meta: ' + repr(self.meta) + ' ' +\
1146            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1147            '>'
1148
1149    def to_dict(self):
1150        return {
1151            'account_attachment': self.account_attachment,
1152            'meta': self.meta,
1153            'rate_limit': self.rate_limit,
1154        }
1155
1156    @classmethod
1157    def from_dict(cls, d):
1158        return cls(
1159            account_attachment=d.get('account_attachment'),
1160            meta=d.get('meta'),
1161            rate_limit=d.get('rate_limit'),
1162        )

AccountAttachmentGetResponse returns a requested AccountAttachment.

AccountAttachmentGetResponse(account_attachment=None, meta=None, rate_limit=None)
1123    def __init__(
1124        self,
1125        account_attachment=None,
1126        meta=None,
1127        rate_limit=None,
1128    ):
1129        self.account_attachment = account_attachment if account_attachment is not None else None
1130        '''
1131         The requested AccountAttachment.
1132        '''
1133        self.meta = meta if meta is not None else None
1134        '''
1135         Reserved for future use.
1136        '''
1137        self.rate_limit = rate_limit if rate_limit is not None else None
1138        '''
1139         Rate limit information.
1140        '''
account_attachment

The requested AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1149    def to_dict(self):
1150        return {
1151            'account_attachment': self.account_attachment,
1152            'meta': self.meta,
1153            'rate_limit': self.rate_limit,
1154        }
@classmethod
def from_dict(cls, d)
1156    @classmethod
1157    def from_dict(cls, d):
1158        return cls(
1159            account_attachment=d.get('account_attachment'),
1160            meta=d.get('meta'),
1161            rate_limit=d.get('rate_limit'),
1162        )
class AccountCreateResponse:
1165class AccountCreateResponse:
1166    '''
1167     AccountCreateResponse reports how the Accounts were created in the system.
1168    '''
1169    __slots__ = [
1170        'account',
1171        'meta',
1172        'rate_limit',
1173        'token',
1174    ]
1175
1176    def __init__(
1177        self,
1178        account=None,
1179        meta=None,
1180        rate_limit=None,
1181        token=None,
1182    ):
1183        self.account = account if account is not None else None
1184        '''
1185         The created Account.
1186        '''
1187        self.meta = meta if meta is not None else None
1188        '''
1189         Reserved for future use.
1190        '''
1191        self.rate_limit = rate_limit if rate_limit is not None else None
1192        '''
1193         Rate limit information.
1194        '''
1195        self.token = token if token is not None else ''
1196        '''
1197         The auth token generated for the Account. The Account will use this token to
1198         authenticate with the strongDM API.
1199        '''
1200
1201    def __repr__(self):
1202        return '<sdm.AccountCreateResponse ' + \
1203            'account: ' + repr(self.account) + ' ' +\
1204            'meta: ' + repr(self.meta) + ' ' +\
1205            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1206            'token: ' + repr(self.token) + ' ' +\
1207            '>'
1208
1209    def to_dict(self):
1210        return {
1211            'account': self.account,
1212            'meta': self.meta,
1213            'rate_limit': self.rate_limit,
1214            'token': self.token,
1215        }
1216
1217    @classmethod
1218    def from_dict(cls, d):
1219        return cls(
1220            account=d.get('account'),
1221            meta=d.get('meta'),
1222            rate_limit=d.get('rate_limit'),
1223            token=d.get('token'),
1224        )

AccountCreateResponse reports how the Accounts were created in the system.

AccountCreateResponse(account=None, meta=None, rate_limit=None, token=None)
1176    def __init__(
1177        self,
1178        account=None,
1179        meta=None,
1180        rate_limit=None,
1181        token=None,
1182    ):
1183        self.account = account if account is not None else None
1184        '''
1185         The created Account.
1186        '''
1187        self.meta = meta if meta is not None else None
1188        '''
1189         Reserved for future use.
1190        '''
1191        self.rate_limit = rate_limit if rate_limit is not None else None
1192        '''
1193         Rate limit information.
1194        '''
1195        self.token = token if token is not None else ''
1196        '''
1197         The auth token generated for the Account. The Account will use this token to
1198         authenticate with the strongDM API.
1199        '''
account

The created Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

token

The auth token generated for the Account. The Account will use this token to authenticate with the strongDM API.

def to_dict(self)
1209    def to_dict(self):
1210        return {
1211            'account': self.account,
1212            'meta': self.meta,
1213            'rate_limit': self.rate_limit,
1214            'token': self.token,
1215        }
@classmethod
def from_dict(cls, d)
1217    @classmethod
1218    def from_dict(cls, d):
1219        return cls(
1220            account=d.get('account'),
1221            meta=d.get('meta'),
1222            rate_limit=d.get('rate_limit'),
1223            token=d.get('token'),
1224        )
class AccountDeleteResponse:
1227class AccountDeleteResponse:
1228    '''
1229     AccountDeleteResponse returns information about a Account that was deleted.
1230    '''
1231    __slots__ = [
1232        'meta',
1233        'rate_limit',
1234    ]
1235
1236    def __init__(
1237        self,
1238        meta=None,
1239        rate_limit=None,
1240    ):
1241        self.meta = meta if meta is not None else None
1242        '''
1243         Reserved for future use.
1244        '''
1245        self.rate_limit = rate_limit if rate_limit is not None else None
1246        '''
1247         Rate limit information.
1248        '''
1249
1250    def __repr__(self):
1251        return '<sdm.AccountDeleteResponse ' + \
1252            'meta: ' + repr(self.meta) + ' ' +\
1253            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1254            '>'
1255
1256    def to_dict(self):
1257        return {
1258            'meta': self.meta,
1259            'rate_limit': self.rate_limit,
1260        }
1261
1262    @classmethod
1263    def from_dict(cls, d):
1264        return cls(
1265            meta=d.get('meta'),
1266            rate_limit=d.get('rate_limit'),
1267        )

AccountDeleteResponse returns information about a Account that was deleted.

AccountDeleteResponse(meta=None, rate_limit=None)
1236    def __init__(
1237        self,
1238        meta=None,
1239        rate_limit=None,
1240    ):
1241        self.meta = meta if meta is not None else None
1242        '''
1243         Reserved for future use.
1244        '''
1245        self.rate_limit = rate_limit if rate_limit is not None else None
1246        '''
1247         Rate limit information.
1248        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1256    def to_dict(self):
1257        return {
1258            'meta': self.meta,
1259            'rate_limit': self.rate_limit,
1260        }
@classmethod
def from_dict(cls, d)
1262    @classmethod
1263    def from_dict(cls, d):
1264        return cls(
1265            meta=d.get('meta'),
1266            rate_limit=d.get('rate_limit'),
1267        )
class AccountGetResponse:
1270class AccountGetResponse:
1271    '''
1272     AccountGetResponse returns a requested Account.
1273    '''
1274    __slots__ = [
1275        'account',
1276        'meta',
1277        'rate_limit',
1278    ]
1279
1280    def __init__(
1281        self,
1282        account=None,
1283        meta=None,
1284        rate_limit=None,
1285    ):
1286        self.account = account if account is not None else None
1287        '''
1288         The requested Account.
1289        '''
1290        self.meta = meta if meta is not None else None
1291        '''
1292         Reserved for future use.
1293        '''
1294        self.rate_limit = rate_limit if rate_limit is not None else None
1295        '''
1296         Rate limit information.
1297        '''
1298
1299    def __repr__(self):
1300        return '<sdm.AccountGetResponse ' + \
1301            'account: ' + repr(self.account) + ' ' +\
1302            'meta: ' + repr(self.meta) + ' ' +\
1303            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1304            '>'
1305
1306    def to_dict(self):
1307        return {
1308            'account': self.account,
1309            'meta': self.meta,
1310            'rate_limit': self.rate_limit,
1311        }
1312
1313    @classmethod
1314    def from_dict(cls, d):
1315        return cls(
1316            account=d.get('account'),
1317            meta=d.get('meta'),
1318            rate_limit=d.get('rate_limit'),
1319        )

AccountGetResponse returns a requested Account.

AccountGetResponse(account=None, meta=None, rate_limit=None)
1280    def __init__(
1281        self,
1282        account=None,
1283        meta=None,
1284        rate_limit=None,
1285    ):
1286        self.account = account if account is not None else None
1287        '''
1288         The requested Account.
1289        '''
1290        self.meta = meta if meta is not None else None
1291        '''
1292         Reserved for future use.
1293        '''
1294        self.rate_limit = rate_limit if rate_limit is not None else None
1295        '''
1296         Rate limit information.
1297        '''
account

The requested Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1306    def to_dict(self):
1307        return {
1308            'account': self.account,
1309            'meta': self.meta,
1310            'rate_limit': self.rate_limit,
1311        }
@classmethod
def from_dict(cls, d)
1313    @classmethod
1314    def from_dict(cls, d):
1315        return cls(
1316            account=d.get('account'),
1317            meta=d.get('meta'),
1318            rate_limit=d.get('rate_limit'),
1319        )
class AccountGrant:
1322class AccountGrant:
1323    '''
1324     AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
1325    '''
1326    __slots__ = [
1327        'account_id',
1328        'id',
1329        'resource_id',
1330        'start_from',
1331        'valid_until',
1332    ]
1333
1334    def __init__(
1335        self,
1336        account_id=None,
1337        id=None,
1338        resource_id=None,
1339        start_from=None,
1340        valid_until=None,
1341    ):
1342        self.account_id = account_id if account_id is not None else ''
1343        '''
1344         The account id of this AccountGrant.
1345        '''
1346        self.id = id if id is not None else ''
1347        '''
1348         Unique identifier of the AccountGrant.
1349        '''
1350        self.resource_id = resource_id if resource_id is not None else ''
1351        '''
1352         The resource id of this AccountGrant.
1353        '''
1354        self.start_from = start_from if start_from is not None else None
1355        '''
1356         The timestamp when the resource will be granted. Optional. Both start_at
1357         and end_at must be defined together, or not defined at all.
1358        '''
1359        self.valid_until = valid_until if valid_until is not None else None
1360        '''
1361         The timestamp when the resource grant will expire. Optional. Both
1362         start_at and end_at must be defined together, or not defined at all.
1363        '''
1364
1365    def __repr__(self):
1366        return '<sdm.AccountGrant ' + \
1367            'account_id: ' + repr(self.account_id) + ' ' +\
1368            'id: ' + repr(self.id) + ' ' +\
1369            'resource_id: ' + repr(self.resource_id) + ' ' +\
1370            'start_from: ' + repr(self.start_from) + ' ' +\
1371            'valid_until: ' + repr(self.valid_until) + ' ' +\
1372            '>'
1373
1374    def to_dict(self):
1375        return {
1376            'account_id': self.account_id,
1377            'id': self.id,
1378            'resource_id': self.resource_id,
1379            'start_from': self.start_from,
1380            'valid_until': self.valid_until,
1381        }
1382
1383    @classmethod
1384    def from_dict(cls, d):
1385        return cls(
1386            account_id=d.get('account_id'),
1387            id=d.get('id'),
1388            resource_id=d.get('resource_id'),
1389            start_from=d.get('start_from'),
1390            valid_until=d.get('valid_until'),
1391        )

AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.

AccountGrant( account_id=None, id=None, resource_id=None, start_from=None, valid_until=None)
1334    def __init__(
1335        self,
1336        account_id=None,
1337        id=None,
1338        resource_id=None,
1339        start_from=None,
1340        valid_until=None,
1341    ):
1342        self.account_id = account_id if account_id is not None else ''
1343        '''
1344         The account id of this AccountGrant.
1345        '''
1346        self.id = id if id is not None else ''
1347        '''
1348         Unique identifier of the AccountGrant.
1349        '''
1350        self.resource_id = resource_id if resource_id is not None else ''
1351        '''
1352         The resource id of this AccountGrant.
1353        '''
1354        self.start_from = start_from if start_from is not None else None
1355        '''
1356         The timestamp when the resource will be granted. Optional. Both start_at
1357         and end_at must be defined together, or not defined at all.
1358        '''
1359        self.valid_until = valid_until if valid_until is not None else None
1360        '''
1361         The timestamp when the resource grant will expire. Optional. Both
1362         start_at and end_at must be defined together, or not defined at all.
1363        '''
account_id

The account id of this AccountGrant.

id

Unique identifier of the AccountGrant.

resource_id

The resource id of this AccountGrant.

start_from

The timestamp when the resource will be granted. Optional. Both start_at and end_at must be defined together, or not defined at all.

valid_until

The timestamp when the resource grant will expire. Optional. Both start_at and end_at must be defined together, or not defined at all.

def to_dict(self)
1374    def to_dict(self):
1375        return {
1376            'account_id': self.account_id,
1377            'id': self.id,
1378            'resource_id': self.resource_id,
1379            'start_from': self.start_from,
1380            'valid_until': self.valid_until,
1381        }
@classmethod
def from_dict(cls, d)
1383    @classmethod
1384    def from_dict(cls, d):
1385        return cls(
1386            account_id=d.get('account_id'),
1387            id=d.get('id'),
1388            resource_id=d.get('resource_id'),
1389            start_from=d.get('start_from'),
1390            valid_until=d.get('valid_until'),
1391        )
class AccountGrantCreateResponse:
1394class AccountGrantCreateResponse:
1395    '''
1396     AccountGrantCreateResponse reports how the AccountGrants were created in the system.
1397    '''
1398    __slots__ = [
1399        'account_grant',
1400        'meta',
1401        'rate_limit',
1402    ]
1403
1404    def __init__(
1405        self,
1406        account_grant=None,
1407        meta=None,
1408        rate_limit=None,
1409    ):
1410        self.account_grant = account_grant if account_grant is not None else None
1411        '''
1412         The created AccountGrant.
1413        '''
1414        self.meta = meta if meta is not None else None
1415        '''
1416         Reserved for future use.
1417        '''
1418        self.rate_limit = rate_limit if rate_limit is not None else None
1419        '''
1420         Rate limit information.
1421        '''
1422
1423    def __repr__(self):
1424        return '<sdm.AccountGrantCreateResponse ' + \
1425            'account_grant: ' + repr(self.account_grant) + ' ' +\
1426            'meta: ' + repr(self.meta) + ' ' +\
1427            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1428            '>'
1429
1430    def to_dict(self):
1431        return {
1432            'account_grant': self.account_grant,
1433            'meta': self.meta,
1434            'rate_limit': self.rate_limit,
1435        }
1436
1437    @classmethod
1438    def from_dict(cls, d):
1439        return cls(
1440            account_grant=d.get('account_grant'),
1441            meta=d.get('meta'),
1442            rate_limit=d.get('rate_limit'),
1443        )

AccountGrantCreateResponse reports how the AccountGrants were created in the system.

AccountGrantCreateResponse(account_grant=None, meta=None, rate_limit=None)
1404    def __init__(
1405        self,
1406        account_grant=None,
1407        meta=None,
1408        rate_limit=None,
1409    ):
1410        self.account_grant = account_grant if account_grant is not None else None
1411        '''
1412         The created AccountGrant.
1413        '''
1414        self.meta = meta if meta is not None else None
1415        '''
1416         Reserved for future use.
1417        '''
1418        self.rate_limit = rate_limit if rate_limit is not None else None
1419        '''
1420         Rate limit information.
1421        '''
account_grant

The created AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1430    def to_dict(self):
1431        return {
1432            'account_grant': self.account_grant,
1433            'meta': self.meta,
1434            'rate_limit': self.rate_limit,
1435        }
@classmethod
def from_dict(cls, d)
1437    @classmethod
1438    def from_dict(cls, d):
1439        return cls(
1440            account_grant=d.get('account_grant'),
1441            meta=d.get('meta'),
1442            rate_limit=d.get('rate_limit'),
1443        )
class AccountGrantDeleteResponse:
1446class AccountGrantDeleteResponse:
1447    '''
1448     AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
1449    '''
1450    __slots__ = [
1451        'meta',
1452        'rate_limit',
1453    ]
1454
1455    def __init__(
1456        self,
1457        meta=None,
1458        rate_limit=None,
1459    ):
1460        self.meta = meta if meta is not None else None
1461        '''
1462         Reserved for future use.
1463        '''
1464        self.rate_limit = rate_limit if rate_limit is not None else None
1465        '''
1466         Rate limit information.
1467        '''
1468
1469    def __repr__(self):
1470        return '<sdm.AccountGrantDeleteResponse ' + \
1471            'meta: ' + repr(self.meta) + ' ' +\
1472            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1473            '>'
1474
1475    def to_dict(self):
1476        return {
1477            'meta': self.meta,
1478            'rate_limit': self.rate_limit,
1479        }
1480
1481    @classmethod
1482    def from_dict(cls, d):
1483        return cls(
1484            meta=d.get('meta'),
1485            rate_limit=d.get('rate_limit'),
1486        )

AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.

AccountGrantDeleteResponse(meta=None, rate_limit=None)
1455    def __init__(
1456        self,
1457        meta=None,
1458        rate_limit=None,
1459    ):
1460        self.meta = meta if meta is not None else None
1461        '''
1462         Reserved for future use.
1463        '''
1464        self.rate_limit = rate_limit if rate_limit is not None else None
1465        '''
1466         Rate limit information.
1467        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1475    def to_dict(self):
1476        return {
1477            'meta': self.meta,
1478            'rate_limit': self.rate_limit,
1479        }
@classmethod
def from_dict(cls, d)
1481    @classmethod
1482    def from_dict(cls, d):
1483        return cls(
1484            meta=d.get('meta'),
1485            rate_limit=d.get('rate_limit'),
1486        )
class AccountGrantGetResponse:
1489class AccountGrantGetResponse:
1490    '''
1491     AccountGrantGetResponse returns a requested AccountGrant.
1492    '''
1493    __slots__ = [
1494        'account_grant',
1495        'meta',
1496        'rate_limit',
1497    ]
1498
1499    def __init__(
1500        self,
1501        account_grant=None,
1502        meta=None,
1503        rate_limit=None,
1504    ):
1505        self.account_grant = account_grant if account_grant is not None else None
1506        '''
1507         The requested AccountGrant.
1508        '''
1509        self.meta = meta if meta is not None else None
1510        '''
1511         Reserved for future use.
1512        '''
1513        self.rate_limit = rate_limit if rate_limit is not None else None
1514        '''
1515         Rate limit information.
1516        '''
1517
1518    def __repr__(self):
1519        return '<sdm.AccountGrantGetResponse ' + \
1520            'account_grant: ' + repr(self.account_grant) + ' ' +\
1521            'meta: ' + repr(self.meta) + ' ' +\
1522            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1523            '>'
1524
1525    def to_dict(self):
1526        return {
1527            'account_grant': self.account_grant,
1528            'meta': self.meta,
1529            'rate_limit': self.rate_limit,
1530        }
1531
1532    @classmethod
1533    def from_dict(cls, d):
1534        return cls(
1535            account_grant=d.get('account_grant'),
1536            meta=d.get('meta'),
1537            rate_limit=d.get('rate_limit'),
1538        )

AccountGrantGetResponse returns a requested AccountGrant.

AccountGrantGetResponse(account_grant=None, meta=None, rate_limit=None)
1499    def __init__(
1500        self,
1501        account_grant=None,
1502        meta=None,
1503        rate_limit=None,
1504    ):
1505        self.account_grant = account_grant if account_grant is not None else None
1506        '''
1507         The requested AccountGrant.
1508        '''
1509        self.meta = meta if meta is not None else None
1510        '''
1511         Reserved for future use.
1512        '''
1513        self.rate_limit = rate_limit if rate_limit is not None else None
1514        '''
1515         Rate limit information.
1516        '''
account_grant

The requested AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1525    def to_dict(self):
1526        return {
1527            'account_grant': self.account_grant,
1528            'meta': self.meta,
1529            'rate_limit': self.rate_limit,
1530        }
@classmethod
def from_dict(cls, d)
1532    @classmethod
1533    def from_dict(cls, d):
1534        return cls(
1535            account_grant=d.get('account_grant'),
1536            meta=d.get('meta'),
1537            rate_limit=d.get('rate_limit'),
1538        )
class AccountUpdateResponse:
1541class AccountUpdateResponse:
1542    '''
1543     AccountUpdateResponse returns the fields of a Account after it has been updated by
1544     a AccountUpdateRequest.
1545    '''
1546    __slots__ = [
1547        'account',
1548        'meta',
1549        'rate_limit',
1550    ]
1551
1552    def __init__(
1553        self,
1554        account=None,
1555        meta=None,
1556        rate_limit=None,
1557    ):
1558        self.account = account if account is not None else None
1559        '''
1560         The updated Account.
1561        '''
1562        self.meta = meta if meta is not None else None
1563        '''
1564         Reserved for future use.
1565        '''
1566        self.rate_limit = rate_limit if rate_limit is not None else None
1567        '''
1568         Rate limit information.
1569        '''
1570
1571    def __repr__(self):
1572        return '<sdm.AccountUpdateResponse ' + \
1573            'account: ' + repr(self.account) + ' ' +\
1574            'meta: ' + repr(self.meta) + ' ' +\
1575            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1576            '>'
1577
1578    def to_dict(self):
1579        return {
1580            'account': self.account,
1581            'meta': self.meta,
1582            'rate_limit': self.rate_limit,
1583        }
1584
1585    @classmethod
1586    def from_dict(cls, d):
1587        return cls(
1588            account=d.get('account'),
1589            meta=d.get('meta'),
1590            rate_limit=d.get('rate_limit'),
1591        )

AccountUpdateResponse returns the fields of a Account after it has been updated by a AccountUpdateRequest.

AccountUpdateResponse(account=None, meta=None, rate_limit=None)
1552    def __init__(
1553        self,
1554        account=None,
1555        meta=None,
1556        rate_limit=None,
1557    ):
1558        self.account = account if account is not None else None
1559        '''
1560         The updated Account.
1561        '''
1562        self.meta = meta if meta is not None else None
1563        '''
1564         Reserved for future use.
1565        '''
1566        self.rate_limit = rate_limit if rate_limit is not None else None
1567        '''
1568         Rate limit information.
1569        '''
account

The updated Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1578    def to_dict(self):
1579        return {
1580            'account': self.account,
1581            'meta': self.meta,
1582            'rate_limit': self.rate_limit,
1583        }
@classmethod
def from_dict(cls, d)
1585    @classmethod
1586    def from_dict(cls, d):
1587        return cls(
1588            account=d.get('account'),
1589            meta=d.get('meta'),
1590            rate_limit=d.get('rate_limit'),
1591        )
class AmazonEKS:
1594class AmazonEKS:
1595    '''
1596
1597    '''
1598    __slots__ = [
1599        'access_key',
1600        'bind_interface',
1601        'certificate_authority',
1602        'cluster_name',
1603        'egress_filter',
1604        'endpoint',
1605        'healthcheck_namespace',
1606        'healthy',
1607        'id',
1608        'name',
1609        'region',
1610        'remote_identity_group_id',
1611        'remote_identity_healthcheck_username',
1612        'role_arn',
1613        'role_external_id',
1614        'secret_access_key',
1615        'secret_store_id',
1616        'tags',
1617    ]
1618
1619    def __init__(
1620        self,
1621        access_key=None,
1622        bind_interface=None,
1623        certificate_authority=None,
1624        cluster_name=None,
1625        egress_filter=None,
1626        endpoint=None,
1627        healthcheck_namespace=None,
1628        healthy=None,
1629        id=None,
1630        name=None,
1631        region=None,
1632        remote_identity_group_id=None,
1633        remote_identity_healthcheck_username=None,
1634        role_arn=None,
1635        role_external_id=None,
1636        secret_access_key=None,
1637        secret_store_id=None,
1638        tags=None,
1639    ):
1640        self.access_key = access_key if access_key is not None else ''
1641        '''
1642
1643        '''
1644        self.bind_interface = bind_interface if bind_interface is not None else ''
1645        '''
1646         Bind interface
1647        '''
1648        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1649        '''
1650
1651        '''
1652        self.cluster_name = cluster_name if cluster_name is not None else ''
1653        '''
1654
1655        '''
1656        self.egress_filter = egress_filter if egress_filter is not None else ''
1657        '''
1658         A filter applied to the routing logic to pin datasource to nodes.
1659        '''
1660        self.endpoint = endpoint if endpoint is not None else ''
1661        '''
1662
1663        '''
1664        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1665        '''
1666         The path used to check the health of your connection.  Defaults to `default`.
1667        '''
1668        self.healthy = healthy if healthy is not None else False
1669        '''
1670         True if the datasource is reachable and the credentials are valid.
1671        '''
1672        self.id = id if id is not None else ''
1673        '''
1674         Unique identifier of the Resource.
1675        '''
1676        self.name = name if name is not None else ''
1677        '''
1678         Unique human-readable name of the Resource.
1679        '''
1680        self.region = region if region is not None else ''
1681        '''
1682
1683        '''
1684        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1685        '''
1686
1687        '''
1688        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1689        '''
1690
1691        '''
1692        self.role_arn = role_arn if role_arn is not None else ''
1693        '''
1694
1695        '''
1696        self.role_external_id = role_external_id if role_external_id is not None else ''
1697        '''
1698
1699        '''
1700        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1701        '''
1702
1703        '''
1704        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1705        '''
1706         ID of the secret store containing credentials for this resource, if any.
1707        '''
1708        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1709        '''
1710         Tags is a map of key, value pairs.
1711        '''
1712
1713    def __repr__(self):
1714        return '<sdm.AmazonEKS ' + \
1715            'access_key: ' + repr(self.access_key) + ' ' +\
1716            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1717            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
1718            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
1719            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1720            'endpoint: ' + repr(self.endpoint) + ' ' +\
1721            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
1722            'healthy: ' + repr(self.healthy) + ' ' +\
1723            'id: ' + repr(self.id) + ' ' +\
1724            'name: ' + repr(self.name) + ' ' +\
1725            'region: ' + repr(self.region) + ' ' +\
1726            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
1727            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
1728            'role_arn: ' + repr(self.role_arn) + ' ' +\
1729            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1730            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1731            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1732            'tags: ' + repr(self.tags) + ' ' +\
1733            '>'
1734
1735    def to_dict(self):
1736        return {
1737            'access_key': self.access_key,
1738            'bind_interface': self.bind_interface,
1739            'certificate_authority': self.certificate_authority,
1740            'cluster_name': self.cluster_name,
1741            'egress_filter': self.egress_filter,
1742            'endpoint': self.endpoint,
1743            'healthcheck_namespace': self.healthcheck_namespace,
1744            'healthy': self.healthy,
1745            'id': self.id,
1746            'name': self.name,
1747            'region': self.region,
1748            'remote_identity_group_id': self.remote_identity_group_id,
1749            'remote_identity_healthcheck_username':
1750            self.remote_identity_healthcheck_username,
1751            'role_arn': self.role_arn,
1752            'role_external_id': self.role_external_id,
1753            'secret_access_key': self.secret_access_key,
1754            'secret_store_id': self.secret_store_id,
1755            'tags': self.tags,
1756        }
1757
1758    @classmethod
1759    def from_dict(cls, d):
1760        return cls(
1761            access_key=d.get('access_key'),
1762            bind_interface=d.get('bind_interface'),
1763            certificate_authority=d.get('certificate_authority'),
1764            cluster_name=d.get('cluster_name'),
1765            egress_filter=d.get('egress_filter'),
1766            endpoint=d.get('endpoint'),
1767            healthcheck_namespace=d.get('healthcheck_namespace'),
1768            healthy=d.get('healthy'),
1769            id=d.get('id'),
1770            name=d.get('name'),
1771            region=d.get('region'),
1772            remote_identity_group_id=d.get('remote_identity_group_id'),
1773            remote_identity_healthcheck_username=d.get(
1774                'remote_identity_healthcheck_username'),
1775            role_arn=d.get('role_arn'),
1776            role_external_id=d.get('role_external_id'),
1777            secret_access_key=d.get('secret_access_key'),
1778            secret_store_id=d.get('secret_store_id'),
1779            tags=d.get('tags'),
1780        )
AmazonEKS( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1619    def __init__(
1620        self,
1621        access_key=None,
1622        bind_interface=None,
1623        certificate_authority=None,
1624        cluster_name=None,
1625        egress_filter=None,
1626        endpoint=None,
1627        healthcheck_namespace=None,
1628        healthy=None,
1629        id=None,
1630        name=None,
1631        region=None,
1632        remote_identity_group_id=None,
1633        remote_identity_healthcheck_username=None,
1634        role_arn=None,
1635        role_external_id=None,
1636        secret_access_key=None,
1637        secret_store_id=None,
1638        tags=None,
1639    ):
1640        self.access_key = access_key if access_key is not None else ''
1641        '''
1642
1643        '''
1644        self.bind_interface = bind_interface if bind_interface is not None else ''
1645        '''
1646         Bind interface
1647        '''
1648        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1649        '''
1650
1651        '''
1652        self.cluster_name = cluster_name if cluster_name is not None else ''
1653        '''
1654
1655        '''
1656        self.egress_filter = egress_filter if egress_filter is not None else ''
1657        '''
1658         A filter applied to the routing logic to pin datasource to nodes.
1659        '''
1660        self.endpoint = endpoint if endpoint is not None else ''
1661        '''
1662
1663        '''
1664        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1665        '''
1666         The path used to check the health of your connection.  Defaults to `default`.
1667        '''
1668        self.healthy = healthy if healthy is not None else False
1669        '''
1670         True if the datasource is reachable and the credentials are valid.
1671        '''
1672        self.id = id if id is not None else ''
1673        '''
1674         Unique identifier of the Resource.
1675        '''
1676        self.name = name if name is not None else ''
1677        '''
1678         Unique human-readable name of the Resource.
1679        '''
1680        self.region = region if region is not None else ''
1681        '''
1682
1683        '''
1684        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1685        '''
1686
1687        '''
1688        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1689        '''
1690
1691        '''
1692        self.role_arn = role_arn if role_arn is not None else ''
1693        '''
1694
1695        '''
1696        self.role_external_id = role_external_id if role_external_id is not None else ''
1697        '''
1698
1699        '''
1700        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1701        '''
1702
1703        '''
1704        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1705        '''
1706         ID of the secret store containing credentials for this resource, if any.
1707        '''
1708        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1709        '''
1710         Tags is a map of key, value pairs.
1711        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
1735    def to_dict(self):
1736        return {
1737            'access_key': self.access_key,
1738            'bind_interface': self.bind_interface,
1739            'certificate_authority': self.certificate_authority,
1740            'cluster_name': self.cluster_name,
1741            'egress_filter': self.egress_filter,
1742            'endpoint': self.endpoint,
1743            'healthcheck_namespace': self.healthcheck_namespace,
1744            'healthy': self.healthy,
1745            'id': self.id,
1746            'name': self.name,
1747            'region': self.region,
1748            'remote_identity_group_id': self.remote_identity_group_id,
1749            'remote_identity_healthcheck_username':
1750            self.remote_identity_healthcheck_username,
1751            'role_arn': self.role_arn,
1752            'role_external_id': self.role_external_id,
1753            'secret_access_key': self.secret_access_key,
1754            'secret_store_id': self.secret_store_id,
1755            'tags': self.tags,
1756        }
@classmethod
def from_dict(cls, d)
1758    @classmethod
1759    def from_dict(cls, d):
1760        return cls(
1761            access_key=d.get('access_key'),
1762            bind_interface=d.get('bind_interface'),
1763            certificate_authority=d.get('certificate_authority'),
1764            cluster_name=d.get('cluster_name'),
1765            egress_filter=d.get('egress_filter'),
1766            endpoint=d.get('endpoint'),
1767            healthcheck_namespace=d.get('healthcheck_namespace'),
1768            healthy=d.get('healthy'),
1769            id=d.get('id'),
1770            name=d.get('name'),
1771            region=d.get('region'),
1772            remote_identity_group_id=d.get('remote_identity_group_id'),
1773            remote_identity_healthcheck_username=d.get(
1774                'remote_identity_healthcheck_username'),
1775            role_arn=d.get('role_arn'),
1776            role_external_id=d.get('role_external_id'),
1777            secret_access_key=d.get('secret_access_key'),
1778            secret_store_id=d.get('secret_store_id'),
1779            tags=d.get('tags'),
1780        )
class AmazonEKSUserImpersonation:
1783class AmazonEKSUserImpersonation:
1784    '''
1785
1786    '''
1787    __slots__ = [
1788        'access_key',
1789        'bind_interface',
1790        'certificate_authority',
1791        'cluster_name',
1792        'egress_filter',
1793        'endpoint',
1794        'healthcheck_namespace',
1795        'healthy',
1796        'id',
1797        'name',
1798        'region',
1799        'role_arn',
1800        'role_external_id',
1801        'secret_access_key',
1802        'secret_store_id',
1803        'tags',
1804    ]
1805
1806    def __init__(
1807        self,
1808        access_key=None,
1809        bind_interface=None,
1810        certificate_authority=None,
1811        cluster_name=None,
1812        egress_filter=None,
1813        endpoint=None,
1814        healthcheck_namespace=None,
1815        healthy=None,
1816        id=None,
1817        name=None,
1818        region=None,
1819        role_arn=None,
1820        role_external_id=None,
1821        secret_access_key=None,
1822        secret_store_id=None,
1823        tags=None,
1824    ):
1825        self.access_key = access_key if access_key is not None else ''
1826        '''
1827
1828        '''
1829        self.bind_interface = bind_interface if bind_interface is not None else ''
1830        '''
1831         Bind interface
1832        '''
1833        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1834        '''
1835
1836        '''
1837        self.cluster_name = cluster_name if cluster_name is not None else ''
1838        '''
1839
1840        '''
1841        self.egress_filter = egress_filter if egress_filter is not None else ''
1842        '''
1843         A filter applied to the routing logic to pin datasource to nodes.
1844        '''
1845        self.endpoint = endpoint if endpoint is not None else ''
1846        '''
1847
1848        '''
1849        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1850        '''
1851         The path used to check the health of your connection.  Defaults to `default`.
1852        '''
1853        self.healthy = healthy if healthy is not None else False
1854        '''
1855         True if the datasource is reachable and the credentials are valid.
1856        '''
1857        self.id = id if id is not None else ''
1858        '''
1859         Unique identifier of the Resource.
1860        '''
1861        self.name = name if name is not None else ''
1862        '''
1863         Unique human-readable name of the Resource.
1864        '''
1865        self.region = region if region is not None else ''
1866        '''
1867
1868        '''
1869        self.role_arn = role_arn if role_arn is not None else ''
1870        '''
1871
1872        '''
1873        self.role_external_id = role_external_id if role_external_id is not None else ''
1874        '''
1875
1876        '''
1877        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1878        '''
1879
1880        '''
1881        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1882        '''
1883         ID of the secret store containing credentials for this resource, if any.
1884        '''
1885        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1886        '''
1887         Tags is a map of key, value pairs.
1888        '''
1889
1890    def __repr__(self):
1891        return '<sdm.AmazonEKSUserImpersonation ' + \
1892            'access_key: ' + repr(self.access_key) + ' ' +\
1893            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1894            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
1895            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
1896            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1897            'endpoint: ' + repr(self.endpoint) + ' ' +\
1898            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
1899            'healthy: ' + repr(self.healthy) + ' ' +\
1900            'id: ' + repr(self.id) + ' ' +\
1901            'name: ' + repr(self.name) + ' ' +\
1902            'region: ' + repr(self.region) + ' ' +\
1903            'role_arn: ' + repr(self.role_arn) + ' ' +\
1904            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1905            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1906            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1907            'tags: ' + repr(self.tags) + ' ' +\
1908            '>'
1909
1910    def to_dict(self):
1911        return {
1912            'access_key': self.access_key,
1913            'bind_interface': self.bind_interface,
1914            'certificate_authority': self.certificate_authority,
1915            'cluster_name': self.cluster_name,
1916            'egress_filter': self.egress_filter,
1917            'endpoint': self.endpoint,
1918            'healthcheck_namespace': self.healthcheck_namespace,
1919            'healthy': self.healthy,
1920            'id': self.id,
1921            'name': self.name,
1922            'region': self.region,
1923            'role_arn': self.role_arn,
1924            'role_external_id': self.role_external_id,
1925            'secret_access_key': self.secret_access_key,
1926            'secret_store_id': self.secret_store_id,
1927            'tags': self.tags,
1928        }
1929
1930    @classmethod
1931    def from_dict(cls, d):
1932        return cls(
1933            access_key=d.get('access_key'),
1934            bind_interface=d.get('bind_interface'),
1935            certificate_authority=d.get('certificate_authority'),
1936            cluster_name=d.get('cluster_name'),
1937            egress_filter=d.get('egress_filter'),
1938            endpoint=d.get('endpoint'),
1939            healthcheck_namespace=d.get('healthcheck_namespace'),
1940            healthy=d.get('healthy'),
1941            id=d.get('id'),
1942            name=d.get('name'),
1943            region=d.get('region'),
1944            role_arn=d.get('role_arn'),
1945            role_external_id=d.get('role_external_id'),
1946            secret_access_key=d.get('secret_access_key'),
1947            secret_store_id=d.get('secret_store_id'),
1948            tags=d.get('tags'),
1949        )
AmazonEKSUserImpersonation( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1806    def __init__(
1807        self,
1808        access_key=None,
1809        bind_interface=None,
1810        certificate_authority=None,
1811        cluster_name=None,
1812        egress_filter=None,
1813        endpoint=None,
1814        healthcheck_namespace=None,
1815        healthy=None,
1816        id=None,
1817        name=None,
1818        region=None,
1819        role_arn=None,
1820        role_external_id=None,
1821        secret_access_key=None,
1822        secret_store_id=None,
1823        tags=None,
1824    ):
1825        self.access_key = access_key if access_key is not None else ''
1826        '''
1827
1828        '''
1829        self.bind_interface = bind_interface if bind_interface is not None else ''
1830        '''
1831         Bind interface
1832        '''
1833        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1834        '''
1835
1836        '''
1837        self.cluster_name = cluster_name if cluster_name is not None else ''
1838        '''
1839
1840        '''
1841        self.egress_filter = egress_filter if egress_filter is not None else ''
1842        '''
1843         A filter applied to the routing logic to pin datasource to nodes.
1844        '''
1845        self.endpoint = endpoint if endpoint is not None else ''
1846        '''
1847
1848        '''
1849        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1850        '''
1851         The path used to check the health of your connection.  Defaults to `default`.
1852        '''
1853        self.healthy = healthy if healthy is not None else False
1854        '''
1855         True if the datasource is reachable and the credentials are valid.
1856        '''
1857        self.id = id if id is not None else ''
1858        '''
1859         Unique identifier of the Resource.
1860        '''
1861        self.name = name if name is not None else ''
1862        '''
1863         Unique human-readable name of the Resource.
1864        '''
1865        self.region = region if region is not None else ''
1866        '''
1867
1868        '''
1869        self.role_arn = role_arn if role_arn is not None else ''
1870        '''
1871
1872        '''
1873        self.role_external_id = role_external_id if role_external_id is not None else ''
1874        '''
1875
1876        '''
1877        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1878        '''
1879
1880        '''
1881        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1882        '''
1883         ID of the secret store containing credentials for this resource, if any.
1884        '''
1885        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1886        '''
1887         Tags is a map of key, value pairs.
1888        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
1910    def to_dict(self):
1911        return {
1912            'access_key': self.access_key,
1913            'bind_interface': self.bind_interface,
1914            'certificate_authority': self.certificate_authority,
1915            'cluster_name': self.cluster_name,
1916            'egress_filter': self.egress_filter,
1917            'endpoint': self.endpoint,
1918            'healthcheck_namespace': self.healthcheck_namespace,
1919            'healthy': self.healthy,
1920            'id': self.id,
1921            'name': self.name,
1922            'region': self.region,
1923            'role_arn': self.role_arn,
1924            'role_external_id': self.role_external_id,
1925            'secret_access_key': self.secret_access_key,
1926            'secret_store_id': self.secret_store_id,
1927            'tags': self.tags,
1928        }
@classmethod
def from_dict(cls, d)
1930    @classmethod
1931    def from_dict(cls, d):
1932        return cls(
1933            access_key=d.get('access_key'),
1934            bind_interface=d.get('bind_interface'),
1935            certificate_authority=d.get('certificate_authority'),
1936            cluster_name=d.get('cluster_name'),
1937            egress_filter=d.get('egress_filter'),
1938            endpoint=d.get('endpoint'),
1939            healthcheck_namespace=d.get('healthcheck_namespace'),
1940            healthy=d.get('healthy'),
1941            id=d.get('id'),
1942            name=d.get('name'),
1943            region=d.get('region'),
1944            role_arn=d.get('role_arn'),
1945            role_external_id=d.get('role_external_id'),
1946            secret_access_key=d.get('secret_access_key'),
1947            secret_store_id=d.get('secret_store_id'),
1948            tags=d.get('tags'),
1949        )
class AmazonES:
1952class AmazonES:
1953    '''
1954
1955    '''
1956    __slots__ = [
1957        'access_key',
1958        'bind_interface',
1959        'egress_filter',
1960        'endpoint',
1961        'healthy',
1962        'id',
1963        'name',
1964        'port_override',
1965        'region',
1966        'role_arn',
1967        'role_external_id',
1968        'secret_access_key',
1969        'secret_store_id',
1970        'tags',
1971    ]
1972
1973    def __init__(
1974        self,
1975        access_key=None,
1976        bind_interface=None,
1977        egress_filter=None,
1978        endpoint=None,
1979        healthy=None,
1980        id=None,
1981        name=None,
1982        port_override=None,
1983        region=None,
1984        role_arn=None,
1985        role_external_id=None,
1986        secret_access_key=None,
1987        secret_store_id=None,
1988        tags=None,
1989    ):
1990        self.access_key = access_key if access_key is not None else ''
1991        '''
1992
1993        '''
1994        self.bind_interface = bind_interface if bind_interface is not None else ''
1995        '''
1996         Bind interface
1997        '''
1998        self.egress_filter = egress_filter if egress_filter is not None else ''
1999        '''
2000         A filter applied to the routing logic to pin datasource to nodes.
2001        '''
2002        self.endpoint = endpoint if endpoint is not None else ''
2003        '''
2004
2005        '''
2006        self.healthy = healthy if healthy is not None else False
2007        '''
2008         True if the datasource is reachable and the credentials are valid.
2009        '''
2010        self.id = id if id is not None else ''
2011        '''
2012         Unique identifier of the Resource.
2013        '''
2014        self.name = name if name is not None else ''
2015        '''
2016         Unique human-readable name of the Resource.
2017        '''
2018        self.port_override = port_override if port_override is not None else 0
2019        '''
2020
2021        '''
2022        self.region = region if region is not None else ''
2023        '''
2024
2025        '''
2026        self.role_arn = role_arn if role_arn is not None else ''
2027        '''
2028
2029        '''
2030        self.role_external_id = role_external_id if role_external_id is not None else ''
2031        '''
2032
2033        '''
2034        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2035        '''
2036
2037        '''
2038        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2039        '''
2040         ID of the secret store containing credentials for this resource, if any.
2041        '''
2042        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2043        '''
2044         Tags is a map of key, value pairs.
2045        '''
2046
2047    def __repr__(self):
2048        return '<sdm.AmazonES ' + \
2049            'access_key: ' + repr(self.access_key) + ' ' +\
2050            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2051            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2052            'endpoint: ' + repr(self.endpoint) + ' ' +\
2053            'healthy: ' + repr(self.healthy) + ' ' +\
2054            'id: ' + repr(self.id) + ' ' +\
2055            'name: ' + repr(self.name) + ' ' +\
2056            'port_override: ' + repr(self.port_override) + ' ' +\
2057            'region: ' + repr(self.region) + ' ' +\
2058            'role_arn: ' + repr(self.role_arn) + ' ' +\
2059            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2060            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2061            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2062            'tags: ' + repr(self.tags) + ' ' +\
2063            '>'
2064
2065    def to_dict(self):
2066        return {
2067            'access_key': self.access_key,
2068            'bind_interface': self.bind_interface,
2069            'egress_filter': self.egress_filter,
2070            'endpoint': self.endpoint,
2071            'healthy': self.healthy,
2072            'id': self.id,
2073            'name': self.name,
2074            'port_override': self.port_override,
2075            'region': self.region,
2076            'role_arn': self.role_arn,
2077            'role_external_id': self.role_external_id,
2078            'secret_access_key': self.secret_access_key,
2079            'secret_store_id': self.secret_store_id,
2080            'tags': self.tags,
2081        }
2082
2083    @classmethod
2084    def from_dict(cls, d):
2085        return cls(
2086            access_key=d.get('access_key'),
2087            bind_interface=d.get('bind_interface'),
2088            egress_filter=d.get('egress_filter'),
2089            endpoint=d.get('endpoint'),
2090            healthy=d.get('healthy'),
2091            id=d.get('id'),
2092            name=d.get('name'),
2093            port_override=d.get('port_override'),
2094            region=d.get('region'),
2095            role_arn=d.get('role_arn'),
2096            role_external_id=d.get('role_external_id'),
2097            secret_access_key=d.get('secret_access_key'),
2098            secret_store_id=d.get('secret_store_id'),
2099            tags=d.get('tags'),
2100        )
AmazonES( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1973    def __init__(
1974        self,
1975        access_key=None,
1976        bind_interface=None,
1977        egress_filter=None,
1978        endpoint=None,
1979        healthy=None,
1980        id=None,
1981        name=None,
1982        port_override=None,
1983        region=None,
1984        role_arn=None,
1985        role_external_id=None,
1986        secret_access_key=None,
1987        secret_store_id=None,
1988        tags=None,
1989    ):
1990        self.access_key = access_key if access_key is not None else ''
1991        '''
1992
1993        '''
1994        self.bind_interface = bind_interface if bind_interface is not None else ''
1995        '''
1996         Bind interface
1997        '''
1998        self.egress_filter = egress_filter if egress_filter is not None else ''
1999        '''
2000         A filter applied to the routing logic to pin datasource to nodes.
2001        '''
2002        self.endpoint = endpoint if endpoint is not None else ''
2003        '''
2004
2005        '''
2006        self.healthy = healthy if healthy is not None else False
2007        '''
2008         True if the datasource is reachable and the credentials are valid.
2009        '''
2010        self.id = id if id is not None else ''
2011        '''
2012         Unique identifier of the Resource.
2013        '''
2014        self.name = name if name is not None else ''
2015        '''
2016         Unique human-readable name of the Resource.
2017        '''
2018        self.port_override = port_override if port_override is not None else 0
2019        '''
2020
2021        '''
2022        self.region = region if region is not None else ''
2023        '''
2024
2025        '''
2026        self.role_arn = role_arn if role_arn is not None else ''
2027        '''
2028
2029        '''
2030        self.role_external_id = role_external_id if role_external_id is not None else ''
2031        '''
2032
2033        '''
2034        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2035        '''
2036
2037        '''
2038        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2039        '''
2040         ID of the secret store containing credentials for this resource, if any.
2041        '''
2042        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2043        '''
2044         Tags is a map of key, value pairs.
2045        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2065    def to_dict(self):
2066        return {
2067            'access_key': self.access_key,
2068            'bind_interface': self.bind_interface,
2069            'egress_filter': self.egress_filter,
2070            'endpoint': self.endpoint,
2071            'healthy': self.healthy,
2072            'id': self.id,
2073            'name': self.name,
2074            'port_override': self.port_override,
2075            'region': self.region,
2076            'role_arn': self.role_arn,
2077            'role_external_id': self.role_external_id,
2078            'secret_access_key': self.secret_access_key,
2079            'secret_store_id': self.secret_store_id,
2080            'tags': self.tags,
2081        }
@classmethod
def from_dict(cls, d)
2083    @classmethod
2084    def from_dict(cls, d):
2085        return cls(
2086            access_key=d.get('access_key'),
2087            bind_interface=d.get('bind_interface'),
2088            egress_filter=d.get('egress_filter'),
2089            endpoint=d.get('endpoint'),
2090            healthy=d.get('healthy'),
2091            id=d.get('id'),
2092            name=d.get('name'),
2093            port_override=d.get('port_override'),
2094            region=d.get('region'),
2095            role_arn=d.get('role_arn'),
2096            role_external_id=d.get('role_external_id'),
2097            secret_access_key=d.get('secret_access_key'),
2098            secret_store_id=d.get('secret_store_id'),
2099            tags=d.get('tags'),
2100        )
class AmazonMQAMQP091:
2103class AmazonMQAMQP091:
2104    '''
2105
2106    '''
2107    __slots__ = [
2108        'bind_interface',
2109        'egress_filter',
2110        'healthy',
2111        'hostname',
2112        'id',
2113        'name',
2114        'password',
2115        'port',
2116        'port_override',
2117        'secret_store_id',
2118        'tags',
2119        'tls_required',
2120        'username',
2121    ]
2122
2123    def __init__(
2124        self,
2125        bind_interface=None,
2126        egress_filter=None,
2127        healthy=None,
2128        hostname=None,
2129        id=None,
2130        name=None,
2131        password=None,
2132        port=None,
2133        port_override=None,
2134        secret_store_id=None,
2135        tags=None,
2136        tls_required=None,
2137        username=None,
2138    ):
2139        self.bind_interface = bind_interface if bind_interface is not None else ''
2140        '''
2141         Bind interface
2142        '''
2143        self.egress_filter = egress_filter if egress_filter is not None else ''
2144        '''
2145         A filter applied to the routing logic to pin datasource to nodes.
2146        '''
2147        self.healthy = healthy if healthy is not None else False
2148        '''
2149         True if the datasource is reachable and the credentials are valid.
2150        '''
2151        self.hostname = hostname if hostname is not None else ''
2152        '''
2153
2154        '''
2155        self.id = id if id is not None else ''
2156        '''
2157         Unique identifier of the Resource.
2158        '''
2159        self.name = name if name is not None else ''
2160        '''
2161         Unique human-readable name of the Resource.
2162        '''
2163        self.password = password if password is not None else ''
2164        '''
2165
2166        '''
2167        self.port = port if port is not None else 0
2168        '''
2169
2170        '''
2171        self.port_override = port_override if port_override is not None else 0
2172        '''
2173
2174        '''
2175        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2176        '''
2177         ID of the secret store containing credentials for this resource, if any.
2178        '''
2179        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2180        '''
2181         Tags is a map of key, value pairs.
2182        '''
2183        self.tls_required = tls_required if tls_required is not None else False
2184        '''
2185
2186        '''
2187        self.username = username if username is not None else ''
2188        '''
2189
2190        '''
2191
2192    def __repr__(self):
2193        return '<sdm.AmazonMQAMQP091 ' + \
2194            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2195            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2196            'healthy: ' + repr(self.healthy) + ' ' +\
2197            'hostname: ' + repr(self.hostname) + ' ' +\
2198            'id: ' + repr(self.id) + ' ' +\
2199            'name: ' + repr(self.name) + ' ' +\
2200            'password: ' + repr(self.password) + ' ' +\
2201            'port: ' + repr(self.port) + ' ' +\
2202            'port_override: ' + repr(self.port_override) + ' ' +\
2203            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2204            'tags: ' + repr(self.tags) + ' ' +\
2205            'tls_required: ' + repr(self.tls_required) + ' ' +\
2206            'username: ' + repr(self.username) + ' ' +\
2207            '>'
2208
2209    def to_dict(self):
2210        return {
2211            'bind_interface': self.bind_interface,
2212            'egress_filter': self.egress_filter,
2213            'healthy': self.healthy,
2214            'hostname': self.hostname,
2215            'id': self.id,
2216            'name': self.name,
2217            'password': self.password,
2218            'port': self.port,
2219            'port_override': self.port_override,
2220            'secret_store_id': self.secret_store_id,
2221            'tags': self.tags,
2222            'tls_required': self.tls_required,
2223            'username': self.username,
2224        }
2225
2226    @classmethod
2227    def from_dict(cls, d):
2228        return cls(
2229            bind_interface=d.get('bind_interface'),
2230            egress_filter=d.get('egress_filter'),
2231            healthy=d.get('healthy'),
2232            hostname=d.get('hostname'),
2233            id=d.get('id'),
2234            name=d.get('name'),
2235            password=d.get('password'),
2236            port=d.get('port'),
2237            port_override=d.get('port_override'),
2238            secret_store_id=d.get('secret_store_id'),
2239            tags=d.get('tags'),
2240            tls_required=d.get('tls_required'),
2241            username=d.get('username'),
2242        )
AmazonMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
2123    def __init__(
2124        self,
2125        bind_interface=None,
2126        egress_filter=None,
2127        healthy=None,
2128        hostname=None,
2129        id=None,
2130        name=None,
2131        password=None,
2132        port=None,
2133        port_override=None,
2134        secret_store_id=None,
2135        tags=None,
2136        tls_required=None,
2137        username=None,
2138    ):
2139        self.bind_interface = bind_interface if bind_interface is not None else ''
2140        '''
2141         Bind interface
2142        '''
2143        self.egress_filter = egress_filter if egress_filter is not None else ''
2144        '''
2145         A filter applied to the routing logic to pin datasource to nodes.
2146        '''
2147        self.healthy = healthy if healthy is not None else False
2148        '''
2149         True if the datasource is reachable and the credentials are valid.
2150        '''
2151        self.hostname = hostname if hostname is not None else ''
2152        '''
2153
2154        '''
2155        self.id = id if id is not None else ''
2156        '''
2157         Unique identifier of the Resource.
2158        '''
2159        self.name = name if name is not None else ''
2160        '''
2161         Unique human-readable name of the Resource.
2162        '''
2163        self.password = password if password is not None else ''
2164        '''
2165
2166        '''
2167        self.port = port if port is not None else 0
2168        '''
2169
2170        '''
2171        self.port_override = port_override if port_override is not None else 0
2172        '''
2173
2174        '''
2175        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2176        '''
2177         ID of the secret store containing credentials for this resource, if any.
2178        '''
2179        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2180        '''
2181         Tags is a map of key, value pairs.
2182        '''
2183        self.tls_required = tls_required if tls_required is not None else False
2184        '''
2185
2186        '''
2187        self.username = username if username is not None else ''
2188        '''
2189
2190        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
2209    def to_dict(self):
2210        return {
2211            'bind_interface': self.bind_interface,
2212            'egress_filter': self.egress_filter,
2213            'healthy': self.healthy,
2214            'hostname': self.hostname,
2215            'id': self.id,
2216            'name': self.name,
2217            'password': self.password,
2218            'port': self.port,
2219            'port_override': self.port_override,
2220            'secret_store_id': self.secret_store_id,
2221            'tags': self.tags,
2222            'tls_required': self.tls_required,
2223            'username': self.username,
2224        }
@classmethod
def from_dict(cls, d)
2226    @classmethod
2227    def from_dict(cls, d):
2228        return cls(
2229            bind_interface=d.get('bind_interface'),
2230            egress_filter=d.get('egress_filter'),
2231            healthy=d.get('healthy'),
2232            hostname=d.get('hostname'),
2233            id=d.get('id'),
2234            name=d.get('name'),
2235            password=d.get('password'),
2236            port=d.get('port'),
2237            port_override=d.get('port_override'),
2238            secret_store_id=d.get('secret_store_id'),
2239            tags=d.get('tags'),
2240            tls_required=d.get('tls_required'),
2241            username=d.get('username'),
2242        )
class Athena:
2245class Athena:
2246    '''
2247
2248    '''
2249    __slots__ = [
2250        'access_key',
2251        'bind_interface',
2252        'egress_filter',
2253        'healthy',
2254        'id',
2255        'name',
2256        'output',
2257        'port_override',
2258        'region',
2259        'role_arn',
2260        'role_external_id',
2261        'secret_access_key',
2262        'secret_store_id',
2263        'tags',
2264    ]
2265
2266    def __init__(
2267        self,
2268        access_key=None,
2269        bind_interface=None,
2270        egress_filter=None,
2271        healthy=None,
2272        id=None,
2273        name=None,
2274        output=None,
2275        port_override=None,
2276        region=None,
2277        role_arn=None,
2278        role_external_id=None,
2279        secret_access_key=None,
2280        secret_store_id=None,
2281        tags=None,
2282    ):
2283        self.access_key = access_key if access_key is not None else ''
2284        '''
2285
2286        '''
2287        self.bind_interface = bind_interface if bind_interface is not None else ''
2288        '''
2289         Bind interface
2290        '''
2291        self.egress_filter = egress_filter if egress_filter is not None else ''
2292        '''
2293         A filter applied to the routing logic to pin datasource to nodes.
2294        '''
2295        self.healthy = healthy if healthy is not None else False
2296        '''
2297         True if the datasource is reachable and the credentials are valid.
2298        '''
2299        self.id = id if id is not None else ''
2300        '''
2301         Unique identifier of the Resource.
2302        '''
2303        self.name = name if name is not None else ''
2304        '''
2305         Unique human-readable name of the Resource.
2306        '''
2307        self.output = output if output is not None else ''
2308        '''
2309
2310        '''
2311        self.port_override = port_override if port_override is not None else 0
2312        '''
2313
2314        '''
2315        self.region = region if region is not None else ''
2316        '''
2317
2318        '''
2319        self.role_arn = role_arn if role_arn is not None else ''
2320        '''
2321
2322        '''
2323        self.role_external_id = role_external_id if role_external_id is not None else ''
2324        '''
2325
2326        '''
2327        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2328        '''
2329
2330        '''
2331        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2332        '''
2333         ID of the secret store containing credentials for this resource, if any.
2334        '''
2335        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2336        '''
2337         Tags is a map of key, value pairs.
2338        '''
2339
2340    def __repr__(self):
2341        return '<sdm.Athena ' + \
2342            'access_key: ' + repr(self.access_key) + ' ' +\
2343            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2344            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2345            'healthy: ' + repr(self.healthy) + ' ' +\
2346            'id: ' + repr(self.id) + ' ' +\
2347            'name: ' + repr(self.name) + ' ' +\
2348            'output: ' + repr(self.output) + ' ' +\
2349            'port_override: ' + repr(self.port_override) + ' ' +\
2350            'region: ' + repr(self.region) + ' ' +\
2351            'role_arn: ' + repr(self.role_arn) + ' ' +\
2352            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2353            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2354            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2355            'tags: ' + repr(self.tags) + ' ' +\
2356            '>'
2357
2358    def to_dict(self):
2359        return {
2360            'access_key': self.access_key,
2361            'bind_interface': self.bind_interface,
2362            'egress_filter': self.egress_filter,
2363            'healthy': self.healthy,
2364            'id': self.id,
2365            'name': self.name,
2366            'output': self.output,
2367            'port_override': self.port_override,
2368            'region': self.region,
2369            'role_arn': self.role_arn,
2370            'role_external_id': self.role_external_id,
2371            'secret_access_key': self.secret_access_key,
2372            'secret_store_id': self.secret_store_id,
2373            'tags': self.tags,
2374        }
2375
2376    @classmethod
2377    def from_dict(cls, d):
2378        return cls(
2379            access_key=d.get('access_key'),
2380            bind_interface=d.get('bind_interface'),
2381            egress_filter=d.get('egress_filter'),
2382            healthy=d.get('healthy'),
2383            id=d.get('id'),
2384            name=d.get('name'),
2385            output=d.get('output'),
2386            port_override=d.get('port_override'),
2387            region=d.get('region'),
2388            role_arn=d.get('role_arn'),
2389            role_external_id=d.get('role_external_id'),
2390            secret_access_key=d.get('secret_access_key'),
2391            secret_store_id=d.get('secret_store_id'),
2392            tags=d.get('tags'),
2393        )
Athena( access_key=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, output=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
2266    def __init__(
2267        self,
2268        access_key=None,
2269        bind_interface=None,
2270        egress_filter=None,
2271        healthy=None,
2272        id=None,
2273        name=None,
2274        output=None,
2275        port_override=None,
2276        region=None,
2277        role_arn=None,
2278        role_external_id=None,
2279        secret_access_key=None,
2280        secret_store_id=None,
2281        tags=None,
2282    ):
2283        self.access_key = access_key if access_key is not None else ''
2284        '''
2285
2286        '''
2287        self.bind_interface = bind_interface if bind_interface is not None else ''
2288        '''
2289         Bind interface
2290        '''
2291        self.egress_filter = egress_filter if egress_filter is not None else ''
2292        '''
2293         A filter applied to the routing logic to pin datasource to nodes.
2294        '''
2295        self.healthy = healthy if healthy is not None else False
2296        '''
2297         True if the datasource is reachable and the credentials are valid.
2298        '''
2299        self.id = id if id is not None else ''
2300        '''
2301         Unique identifier of the Resource.
2302        '''
2303        self.name = name if name is not None else ''
2304        '''
2305         Unique human-readable name of the Resource.
2306        '''
2307        self.output = output if output is not None else ''
2308        '''
2309
2310        '''
2311        self.port_override = port_override if port_override is not None else 0
2312        '''
2313
2314        '''
2315        self.region = region if region is not None else ''
2316        '''
2317
2318        '''
2319        self.role_arn = role_arn if role_arn is not None else ''
2320        '''
2321
2322        '''
2323        self.role_external_id = role_external_id if role_external_id is not None else ''
2324        '''
2325
2326        '''
2327        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2328        '''
2329
2330        '''
2331        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2332        '''
2333         ID of the secret store containing credentials for this resource, if any.
2334        '''
2335        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2336        '''
2337         Tags is a map of key, value pairs.
2338        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

output
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2358    def to_dict(self):
2359        return {
2360            'access_key': self.access_key,
2361            'bind_interface': self.bind_interface,
2362            'egress_filter': self.egress_filter,
2363            'healthy': self.healthy,
2364            'id': self.id,
2365            'name': self.name,
2366            'output': self.output,
2367            'port_override': self.port_override,
2368            'region': self.region,
2369            'role_arn': self.role_arn,
2370            'role_external_id': self.role_external_id,
2371            'secret_access_key': self.secret_access_key,
2372            'secret_store_id': self.secret_store_id,
2373            'tags': self.tags,
2374        }
@classmethod
def from_dict(cls, d)
2376    @classmethod
2377    def from_dict(cls, d):
2378        return cls(
2379            access_key=d.get('access_key'),
2380            bind_interface=d.get('bind_interface'),
2381            egress_filter=d.get('egress_filter'),
2382            healthy=d.get('healthy'),
2383            id=d.get('id'),
2384            name=d.get('name'),
2385            output=d.get('output'),
2386            port_override=d.get('port_override'),
2387            region=d.get('region'),
2388            role_arn=d.get('role_arn'),
2389            role_external_id=d.get('role_external_id'),
2390            secret_access_key=d.get('secret_access_key'),
2391            secret_store_id=d.get('secret_store_id'),
2392            tags=d.get('tags'),
2393        )
class AuroraMysql:
2396class AuroraMysql:
2397    '''
2398
2399    '''
2400    __slots__ = [
2401        'bind_interface',
2402        'database',
2403        'egress_filter',
2404        'healthy',
2405        'hostname',
2406        'id',
2407        'name',
2408        'password',
2409        'port',
2410        'port_override',
2411        'secret_store_id',
2412        'tags',
2413        'username',
2414    ]
2415
2416    def __init__(
2417        self,
2418        bind_interface=None,
2419        database=None,
2420        egress_filter=None,
2421        healthy=None,
2422        hostname=None,
2423        id=None,
2424        name=None,
2425        password=None,
2426        port=None,
2427        port_override=None,
2428        secret_store_id=None,
2429        tags=None,
2430        username=None,
2431    ):
2432        self.bind_interface = bind_interface if bind_interface is not None else ''
2433        '''
2434         Bind interface
2435        '''
2436        self.database = database if database is not None else ''
2437        '''
2438
2439        '''
2440        self.egress_filter = egress_filter if egress_filter is not None else ''
2441        '''
2442         A filter applied to the routing logic to pin datasource to nodes.
2443        '''
2444        self.healthy = healthy if healthy is not None else False
2445        '''
2446         True if the datasource is reachable and the credentials are valid.
2447        '''
2448        self.hostname = hostname if hostname is not None else ''
2449        '''
2450
2451        '''
2452        self.id = id if id is not None else ''
2453        '''
2454         Unique identifier of the Resource.
2455        '''
2456        self.name = name if name is not None else ''
2457        '''
2458         Unique human-readable name of the Resource.
2459        '''
2460        self.password = password if password is not None else ''
2461        '''
2462
2463        '''
2464        self.port = port if port is not None else 0
2465        '''
2466
2467        '''
2468        self.port_override = port_override if port_override is not None else 0
2469        '''
2470
2471        '''
2472        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2473        '''
2474         ID of the secret store containing credentials for this resource, if any.
2475        '''
2476        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2477        '''
2478         Tags is a map of key, value pairs.
2479        '''
2480        self.username = username if username is not None else ''
2481        '''
2482
2483        '''
2484
2485    def __repr__(self):
2486        return '<sdm.AuroraMysql ' + \
2487            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2488            'database: ' + repr(self.database) + ' ' +\
2489            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2490            'healthy: ' + repr(self.healthy) + ' ' +\
2491            'hostname: ' + repr(self.hostname) + ' ' +\
2492            'id: ' + repr(self.id) + ' ' +\
2493            'name: ' + repr(self.name) + ' ' +\
2494            'password: ' + repr(self.password) + ' ' +\
2495            'port: ' + repr(self.port) + ' ' +\
2496            'port_override: ' + repr(self.port_override) + ' ' +\
2497            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2498            'tags: ' + repr(self.tags) + ' ' +\
2499            'username: ' + repr(self.username) + ' ' +\
2500            '>'
2501
2502    def to_dict(self):
2503        return {
2504            'bind_interface': self.bind_interface,
2505            'database': self.database,
2506            'egress_filter': self.egress_filter,
2507            'healthy': self.healthy,
2508            'hostname': self.hostname,
2509            'id': self.id,
2510            'name': self.name,
2511            'password': self.password,
2512            'port': self.port,
2513            'port_override': self.port_override,
2514            'secret_store_id': self.secret_store_id,
2515            'tags': self.tags,
2516            'username': self.username,
2517        }
2518
2519    @classmethod
2520    def from_dict(cls, d):
2521        return cls(
2522            bind_interface=d.get('bind_interface'),
2523            database=d.get('database'),
2524            egress_filter=d.get('egress_filter'),
2525            healthy=d.get('healthy'),
2526            hostname=d.get('hostname'),
2527            id=d.get('id'),
2528            name=d.get('name'),
2529            password=d.get('password'),
2530            port=d.get('port'),
2531            port_override=d.get('port_override'),
2532            secret_store_id=d.get('secret_store_id'),
2533            tags=d.get('tags'),
2534            username=d.get('username'),
2535        )
AuroraMysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2416    def __init__(
2417        self,
2418        bind_interface=None,
2419        database=None,
2420        egress_filter=None,
2421        healthy=None,
2422        hostname=None,
2423        id=None,
2424        name=None,
2425        password=None,
2426        port=None,
2427        port_override=None,
2428        secret_store_id=None,
2429        tags=None,
2430        username=None,
2431    ):
2432        self.bind_interface = bind_interface if bind_interface is not None else ''
2433        '''
2434         Bind interface
2435        '''
2436        self.database = database if database is not None else ''
2437        '''
2438
2439        '''
2440        self.egress_filter = egress_filter if egress_filter is not None else ''
2441        '''
2442         A filter applied to the routing logic to pin datasource to nodes.
2443        '''
2444        self.healthy = healthy if healthy is not None else False
2445        '''
2446         True if the datasource is reachable and the credentials are valid.
2447        '''
2448        self.hostname = hostname if hostname is not None else ''
2449        '''
2450
2451        '''
2452        self.id = id if id is not None else ''
2453        '''
2454         Unique identifier of the Resource.
2455        '''
2456        self.name = name if name is not None else ''
2457        '''
2458         Unique human-readable name of the Resource.
2459        '''
2460        self.password = password if password is not None else ''
2461        '''
2462
2463        '''
2464        self.port = port if port is not None else 0
2465        '''
2466
2467        '''
2468        self.port_override = port_override if port_override is not None else 0
2469        '''
2470
2471        '''
2472        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2473        '''
2474         ID of the secret store containing credentials for this resource, if any.
2475        '''
2476        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2477        '''
2478         Tags is a map of key, value pairs.
2479        '''
2480        self.username = username if username is not None else ''
2481        '''
2482
2483        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2502    def to_dict(self):
2503        return {
2504            'bind_interface': self.bind_interface,
2505            'database': self.database,
2506            'egress_filter': self.egress_filter,
2507            'healthy': self.healthy,
2508            'hostname': self.hostname,
2509            'id': self.id,
2510            'name': self.name,
2511            'password': self.password,
2512            'port': self.port,
2513            'port_override': self.port_override,
2514            'secret_store_id': self.secret_store_id,
2515            'tags': self.tags,
2516            'username': self.username,
2517        }
@classmethod
def from_dict(cls, d)
2519    @classmethod
2520    def from_dict(cls, d):
2521        return cls(
2522            bind_interface=d.get('bind_interface'),
2523            database=d.get('database'),
2524            egress_filter=d.get('egress_filter'),
2525            healthy=d.get('healthy'),
2526            hostname=d.get('hostname'),
2527            id=d.get('id'),
2528            name=d.get('name'),
2529            password=d.get('password'),
2530            port=d.get('port'),
2531            port_override=d.get('port_override'),
2532            secret_store_id=d.get('secret_store_id'),
2533            tags=d.get('tags'),
2534            username=d.get('username'),
2535        )
class AuroraPostgres:
2538class AuroraPostgres:
2539    '''
2540
2541    '''
2542    __slots__ = [
2543        'bind_interface',
2544        'database',
2545        'egress_filter',
2546        'healthy',
2547        'hostname',
2548        'id',
2549        'name',
2550        'override_database',
2551        'password',
2552        'port',
2553        'port_override',
2554        'secret_store_id',
2555        'tags',
2556        'username',
2557    ]
2558
2559    def __init__(
2560        self,
2561        bind_interface=None,
2562        database=None,
2563        egress_filter=None,
2564        healthy=None,
2565        hostname=None,
2566        id=None,
2567        name=None,
2568        override_database=None,
2569        password=None,
2570        port=None,
2571        port_override=None,
2572        secret_store_id=None,
2573        tags=None,
2574        username=None,
2575    ):
2576        self.bind_interface = bind_interface if bind_interface is not None else ''
2577        '''
2578         Bind interface
2579        '''
2580        self.database = database if database is not None else ''
2581        '''
2582
2583        '''
2584        self.egress_filter = egress_filter if egress_filter is not None else ''
2585        '''
2586         A filter applied to the routing logic to pin datasource to nodes.
2587        '''
2588        self.healthy = healthy if healthy is not None else False
2589        '''
2590         True if the datasource is reachable and the credentials are valid.
2591        '''
2592        self.hostname = hostname if hostname is not None else ''
2593        '''
2594
2595        '''
2596        self.id = id if id is not None else ''
2597        '''
2598         Unique identifier of the Resource.
2599        '''
2600        self.name = name if name is not None else ''
2601        '''
2602         Unique human-readable name of the Resource.
2603        '''
2604        self.override_database = override_database if override_database is not None else False
2605        '''
2606
2607        '''
2608        self.password = password if password is not None else ''
2609        '''
2610
2611        '''
2612        self.port = port if port is not None else 0
2613        '''
2614
2615        '''
2616        self.port_override = port_override if port_override is not None else 0
2617        '''
2618
2619        '''
2620        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2621        '''
2622         ID of the secret store containing credentials for this resource, if any.
2623        '''
2624        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2625        '''
2626         Tags is a map of key, value pairs.
2627        '''
2628        self.username = username if username is not None else ''
2629        '''
2630
2631        '''
2632
2633    def __repr__(self):
2634        return '<sdm.AuroraPostgres ' + \
2635            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2636            'database: ' + repr(self.database) + ' ' +\
2637            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2638            'healthy: ' + repr(self.healthy) + ' ' +\
2639            'hostname: ' + repr(self.hostname) + ' ' +\
2640            'id: ' + repr(self.id) + ' ' +\
2641            'name: ' + repr(self.name) + ' ' +\
2642            'override_database: ' + repr(self.override_database) + ' ' +\
2643            'password: ' + repr(self.password) + ' ' +\
2644            'port: ' + repr(self.port) + ' ' +\
2645            'port_override: ' + repr(self.port_override) + ' ' +\
2646            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2647            'tags: ' + repr(self.tags) + ' ' +\
2648            'username: ' + repr(self.username) + ' ' +\
2649            '>'
2650
2651    def to_dict(self):
2652        return {
2653            'bind_interface': self.bind_interface,
2654            'database': self.database,
2655            'egress_filter': self.egress_filter,
2656            'healthy': self.healthy,
2657            'hostname': self.hostname,
2658            'id': self.id,
2659            'name': self.name,
2660            'override_database': self.override_database,
2661            'password': self.password,
2662            'port': self.port,
2663            'port_override': self.port_override,
2664            'secret_store_id': self.secret_store_id,
2665            'tags': self.tags,
2666            'username': self.username,
2667        }
2668
2669    @classmethod
2670    def from_dict(cls, d):
2671        return cls(
2672            bind_interface=d.get('bind_interface'),
2673            database=d.get('database'),
2674            egress_filter=d.get('egress_filter'),
2675            healthy=d.get('healthy'),
2676            hostname=d.get('hostname'),
2677            id=d.get('id'),
2678            name=d.get('name'),
2679            override_database=d.get('override_database'),
2680            password=d.get('password'),
2681            port=d.get('port'),
2682            port_override=d.get('port_override'),
2683            secret_store_id=d.get('secret_store_id'),
2684            tags=d.get('tags'),
2685            username=d.get('username'),
2686        )
AuroraPostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2559    def __init__(
2560        self,
2561        bind_interface=None,
2562        database=None,
2563        egress_filter=None,
2564        healthy=None,
2565        hostname=None,
2566        id=None,
2567        name=None,
2568        override_database=None,
2569        password=None,
2570        port=None,
2571        port_override=None,
2572        secret_store_id=None,
2573        tags=None,
2574        username=None,
2575    ):
2576        self.bind_interface = bind_interface if bind_interface is not None else ''
2577        '''
2578         Bind interface
2579        '''
2580        self.database = database if database is not None else ''
2581        '''
2582
2583        '''
2584        self.egress_filter = egress_filter if egress_filter is not None else ''
2585        '''
2586         A filter applied to the routing logic to pin datasource to nodes.
2587        '''
2588        self.healthy = healthy if healthy is not None else False
2589        '''
2590         True if the datasource is reachable and the credentials are valid.
2591        '''
2592        self.hostname = hostname if hostname is not None else ''
2593        '''
2594
2595        '''
2596        self.id = id if id is not None else ''
2597        '''
2598         Unique identifier of the Resource.
2599        '''
2600        self.name = name if name is not None else ''
2601        '''
2602         Unique human-readable name of the Resource.
2603        '''
2604        self.override_database = override_database if override_database is not None else False
2605        '''
2606
2607        '''
2608        self.password = password if password is not None else ''
2609        '''
2610
2611        '''
2612        self.port = port if port is not None else 0
2613        '''
2614
2615        '''
2616        self.port_override = port_override if port_override is not None else 0
2617        '''
2618
2619        '''
2620        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2621        '''
2622         ID of the secret store containing credentials for this resource, if any.
2623        '''
2624        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2625        '''
2626         Tags is a map of key, value pairs.
2627        '''
2628        self.username = username if username is not None else ''
2629        '''
2630
2631        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2651    def to_dict(self):
2652        return {
2653            'bind_interface': self.bind_interface,
2654            'database': self.database,
2655            'egress_filter': self.egress_filter,
2656            'healthy': self.healthy,
2657            'hostname': self.hostname,
2658            'id': self.id,
2659            'name': self.name,
2660            'override_database': self.override_database,
2661            'password': self.password,
2662            'port': self.port,
2663            'port_override': self.port_override,
2664            'secret_store_id': self.secret_store_id,
2665            'tags': self.tags,
2666            'username': self.username,
2667        }
@classmethod
def from_dict(cls, d)
2669    @classmethod
2670    def from_dict(cls, d):
2671        return cls(
2672            bind_interface=d.get('bind_interface'),
2673            database=d.get('database'),
2674            egress_filter=d.get('egress_filter'),
2675            healthy=d.get('healthy'),
2676            hostname=d.get('hostname'),
2677            id=d.get('id'),
2678            name=d.get('name'),
2679            override_database=d.get('override_database'),
2680            password=d.get('password'),
2681            port=d.get('port'),
2682            port_override=d.get('port_override'),
2683            secret_store_id=d.get('secret_store_id'),
2684            tags=d.get('tags'),
2685            username=d.get('username'),
2686        )
class Azure:
2689class Azure:
2690    '''
2691
2692    '''
2693    __slots__ = [
2694        'app_id',
2695        'bind_interface',
2696        'egress_filter',
2697        'healthy',
2698        'id',
2699        'name',
2700        'password',
2701        'secret_store_id',
2702        'tags',
2703        'tenant_id',
2704    ]
2705
2706    def __init__(
2707        self,
2708        app_id=None,
2709        bind_interface=None,
2710        egress_filter=None,
2711        healthy=None,
2712        id=None,
2713        name=None,
2714        password=None,
2715        secret_store_id=None,
2716        tags=None,
2717        tenant_id=None,
2718    ):
2719        self.app_id = app_id if app_id is not None else ''
2720        '''
2721
2722        '''
2723        self.bind_interface = bind_interface if bind_interface is not None else ''
2724        '''
2725         Bind interface
2726        '''
2727        self.egress_filter = egress_filter if egress_filter is not None else ''
2728        '''
2729         A filter applied to the routing logic to pin datasource to nodes.
2730        '''
2731        self.healthy = healthy if healthy is not None else False
2732        '''
2733         True if the datasource is reachable and the credentials are valid.
2734        '''
2735        self.id = id if id is not None else ''
2736        '''
2737         Unique identifier of the Resource.
2738        '''
2739        self.name = name if name is not None else ''
2740        '''
2741         Unique human-readable name of the Resource.
2742        '''
2743        self.password = password if password is not None else ''
2744        '''
2745
2746        '''
2747        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2748        '''
2749         ID of the secret store containing credentials for this resource, if any.
2750        '''
2751        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2752        '''
2753         Tags is a map of key, value pairs.
2754        '''
2755        self.tenant_id = tenant_id if tenant_id is not None else ''
2756        '''
2757
2758        '''
2759
2760    def __repr__(self):
2761        return '<sdm.Azure ' + \
2762            'app_id: ' + repr(self.app_id) + ' ' +\
2763            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2764            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2765            'healthy: ' + repr(self.healthy) + ' ' +\
2766            'id: ' + repr(self.id) + ' ' +\
2767            'name: ' + repr(self.name) + ' ' +\
2768            'password: ' + repr(self.password) + ' ' +\
2769            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2770            'tags: ' + repr(self.tags) + ' ' +\
2771            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2772            '>'
2773
2774    def to_dict(self):
2775        return {
2776            'app_id': self.app_id,
2777            'bind_interface': self.bind_interface,
2778            'egress_filter': self.egress_filter,
2779            'healthy': self.healthy,
2780            'id': self.id,
2781            'name': self.name,
2782            'password': self.password,
2783            'secret_store_id': self.secret_store_id,
2784            'tags': self.tags,
2785            'tenant_id': self.tenant_id,
2786        }
2787
2788    @classmethod
2789    def from_dict(cls, d):
2790        return cls(
2791            app_id=d.get('app_id'),
2792            bind_interface=d.get('bind_interface'),
2793            egress_filter=d.get('egress_filter'),
2794            healthy=d.get('healthy'),
2795            id=d.get('id'),
2796            name=d.get('name'),
2797            password=d.get('password'),
2798            secret_store_id=d.get('secret_store_id'),
2799            tags=d.get('tags'),
2800            tenant_id=d.get('tenant_id'),
2801        )
Azure( app_id=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, tags=None, tenant_id=None)
2706    def __init__(
2707        self,
2708        app_id=None,
2709        bind_interface=None,
2710        egress_filter=None,
2711        healthy=None,
2712        id=None,
2713        name=None,
2714        password=None,
2715        secret_store_id=None,
2716        tags=None,
2717        tenant_id=None,
2718    ):
2719        self.app_id = app_id if app_id is not None else ''
2720        '''
2721
2722        '''
2723        self.bind_interface = bind_interface if bind_interface is not None else ''
2724        '''
2725         Bind interface
2726        '''
2727        self.egress_filter = egress_filter if egress_filter is not None else ''
2728        '''
2729         A filter applied to the routing logic to pin datasource to nodes.
2730        '''
2731        self.healthy = healthy if healthy is not None else False
2732        '''
2733         True if the datasource is reachable and the credentials are valid.
2734        '''
2735        self.id = id if id is not None else ''
2736        '''
2737         Unique identifier of the Resource.
2738        '''
2739        self.name = name if name is not None else ''
2740        '''
2741         Unique human-readable name of the Resource.
2742        '''
2743        self.password = password if password is not None else ''
2744        '''
2745
2746        '''
2747        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2748        '''
2749         ID of the secret store containing credentials for this resource, if any.
2750        '''
2751        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2752        '''
2753         Tags is a map of key, value pairs.
2754        '''
2755        self.tenant_id = tenant_id if tenant_id is not None else ''
2756        '''
2757
2758        '''
app_id
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2774    def to_dict(self):
2775        return {
2776            'app_id': self.app_id,
2777            'bind_interface': self.bind_interface,
2778            'egress_filter': self.egress_filter,
2779            'healthy': self.healthy,
2780            'id': self.id,
2781            'name': self.name,
2782            'password': self.password,
2783            'secret_store_id': self.secret_store_id,
2784            'tags': self.tags,
2785            'tenant_id': self.tenant_id,
2786        }
@classmethod
def from_dict(cls, d)
2788    @classmethod
2789    def from_dict(cls, d):
2790        return cls(
2791            app_id=d.get('app_id'),
2792            bind_interface=d.get('bind_interface'),
2793            egress_filter=d.get('egress_filter'),
2794            healthy=d.get('healthy'),
2795            id=d.get('id'),
2796            name=d.get('name'),
2797            password=d.get('password'),
2798            secret_store_id=d.get('secret_store_id'),
2799            tags=d.get('tags'),
2800            tenant_id=d.get('tenant_id'),
2801        )
class AzureCertificate:
2804class AzureCertificate:
2805    '''
2806
2807    '''
2808    __slots__ = [
2809        'app_id',
2810        'bind_interface',
2811        'client_certificate',
2812        'egress_filter',
2813        'healthy',
2814        'id',
2815        'name',
2816        'secret_store_id',
2817        'tags',
2818        'tenant_id',
2819    ]
2820
2821    def __init__(
2822        self,
2823        app_id=None,
2824        bind_interface=None,
2825        client_certificate=None,
2826        egress_filter=None,
2827        healthy=None,
2828        id=None,
2829        name=None,
2830        secret_store_id=None,
2831        tags=None,
2832        tenant_id=None,
2833    ):
2834        self.app_id = app_id if app_id is not None else ''
2835        '''
2836
2837        '''
2838        self.bind_interface = bind_interface if bind_interface is not None else ''
2839        '''
2840         Bind interface
2841        '''
2842        self.client_certificate = client_certificate if client_certificate is not None else ''
2843        '''
2844
2845        '''
2846        self.egress_filter = egress_filter if egress_filter is not None else ''
2847        '''
2848         A filter applied to the routing logic to pin datasource to nodes.
2849        '''
2850        self.healthy = healthy if healthy is not None else False
2851        '''
2852         True if the datasource is reachable and the credentials are valid.
2853        '''
2854        self.id = id if id is not None else ''
2855        '''
2856         Unique identifier of the Resource.
2857        '''
2858        self.name = name if name is not None else ''
2859        '''
2860         Unique human-readable name of the Resource.
2861        '''
2862        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2863        '''
2864         ID of the secret store containing credentials for this resource, if any.
2865        '''
2866        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2867        '''
2868         Tags is a map of key, value pairs.
2869        '''
2870        self.tenant_id = tenant_id if tenant_id is not None else ''
2871        '''
2872
2873        '''
2874
2875    def __repr__(self):
2876        return '<sdm.AzureCertificate ' + \
2877            'app_id: ' + repr(self.app_id) + ' ' +\
2878            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2879            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
2880            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2881            'healthy: ' + repr(self.healthy) + ' ' +\
2882            'id: ' + repr(self.id) + ' ' +\
2883            'name: ' + repr(self.name) + ' ' +\
2884            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2885            'tags: ' + repr(self.tags) + ' ' +\
2886            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2887            '>'
2888
2889    def to_dict(self):
2890        return {
2891            'app_id': self.app_id,
2892            'bind_interface': self.bind_interface,
2893            'client_certificate': self.client_certificate,
2894            'egress_filter': self.egress_filter,
2895            'healthy': self.healthy,
2896            'id': self.id,
2897            'name': self.name,
2898            'secret_store_id': self.secret_store_id,
2899            'tags': self.tags,
2900            'tenant_id': self.tenant_id,
2901        }
2902
2903    @classmethod
2904    def from_dict(cls, d):
2905        return cls(
2906            app_id=d.get('app_id'),
2907            bind_interface=d.get('bind_interface'),
2908            client_certificate=d.get('client_certificate'),
2909            egress_filter=d.get('egress_filter'),
2910            healthy=d.get('healthy'),
2911            id=d.get('id'),
2912            name=d.get('name'),
2913            secret_store_id=d.get('secret_store_id'),
2914            tags=d.get('tags'),
2915            tenant_id=d.get('tenant_id'),
2916        )
AzureCertificate( app_id=None, bind_interface=None, client_certificate=None, egress_filter=None, healthy=None, id=None, name=None, secret_store_id=None, tags=None, tenant_id=None)
2821    def __init__(
2822        self,
2823        app_id=None,
2824        bind_interface=None,
2825        client_certificate=None,
2826        egress_filter=None,
2827        healthy=None,
2828        id=None,
2829        name=None,
2830        secret_store_id=None,
2831        tags=None,
2832        tenant_id=None,
2833    ):
2834        self.app_id = app_id if app_id is not None else ''
2835        '''
2836
2837        '''
2838        self.bind_interface = bind_interface if bind_interface is not None else ''
2839        '''
2840         Bind interface
2841        '''
2842        self.client_certificate = client_certificate if client_certificate is not None else ''
2843        '''
2844
2845        '''
2846        self.egress_filter = egress_filter if egress_filter is not None else ''
2847        '''
2848         A filter applied to the routing logic to pin datasource to nodes.
2849        '''
2850        self.healthy = healthy if healthy is not None else False
2851        '''
2852         True if the datasource is reachable and the credentials are valid.
2853        '''
2854        self.id = id if id is not None else ''
2855        '''
2856         Unique identifier of the Resource.
2857        '''
2858        self.name = name if name is not None else ''
2859        '''
2860         Unique human-readable name of the Resource.
2861        '''
2862        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2863        '''
2864         ID of the secret store containing credentials for this resource, if any.
2865        '''
2866        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2867        '''
2868         Tags is a map of key, value pairs.
2869        '''
2870        self.tenant_id = tenant_id if tenant_id is not None else ''
2871        '''
2872
2873        '''
app_id
bind_interface

Bind interface

client_certificate
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2889    def to_dict(self):
2890        return {
2891            'app_id': self.app_id,
2892            'bind_interface': self.bind_interface,
2893            'client_certificate': self.client_certificate,
2894            'egress_filter': self.egress_filter,
2895            'healthy': self.healthy,
2896            'id': self.id,
2897            'name': self.name,
2898            'secret_store_id': self.secret_store_id,
2899            'tags': self.tags,
2900            'tenant_id': self.tenant_id,
2901        }
@classmethod
def from_dict(cls, d)
2903    @classmethod
2904    def from_dict(cls, d):
2905        return cls(
2906            app_id=d.get('app_id'),
2907            bind_interface=d.get('bind_interface'),
2908            client_certificate=d.get('client_certificate'),
2909            egress_filter=d.get('egress_filter'),
2910            healthy=d.get('healthy'),
2911            id=d.get('id'),
2912            name=d.get('name'),
2913            secret_store_id=d.get('secret_store_id'),
2914            tags=d.get('tags'),
2915            tenant_id=d.get('tenant_id'),
2916        )
class AzurePostgres:
2919class AzurePostgres:
2920    '''
2921
2922    '''
2923    __slots__ = [
2924        'bind_interface',
2925        'database',
2926        'egress_filter',
2927        'healthy',
2928        'hostname',
2929        'id',
2930        'name',
2931        'override_database',
2932        'password',
2933        'port',
2934        'port_override',
2935        'secret_store_id',
2936        'tags',
2937        'username',
2938    ]
2939
2940    def __init__(
2941        self,
2942        bind_interface=None,
2943        database=None,
2944        egress_filter=None,
2945        healthy=None,
2946        hostname=None,
2947        id=None,
2948        name=None,
2949        override_database=None,
2950        password=None,
2951        port=None,
2952        port_override=None,
2953        secret_store_id=None,
2954        tags=None,
2955        username=None,
2956    ):
2957        self.bind_interface = bind_interface if bind_interface is not None else ''
2958        '''
2959         Bind interface
2960        '''
2961        self.database = database if database is not None else ''
2962        '''
2963
2964        '''
2965        self.egress_filter = egress_filter if egress_filter is not None else ''
2966        '''
2967         A filter applied to the routing logic to pin datasource to nodes.
2968        '''
2969        self.healthy = healthy if healthy is not None else False
2970        '''
2971         True if the datasource is reachable and the credentials are valid.
2972        '''
2973        self.hostname = hostname if hostname is not None else ''
2974        '''
2975
2976        '''
2977        self.id = id if id is not None else ''
2978        '''
2979         Unique identifier of the Resource.
2980        '''
2981        self.name = name if name is not None else ''
2982        '''
2983         Unique human-readable name of the Resource.
2984        '''
2985        self.override_database = override_database if override_database is not None else False
2986        '''
2987
2988        '''
2989        self.password = password if password is not None else ''
2990        '''
2991
2992        '''
2993        self.port = port if port is not None else 0
2994        '''
2995
2996        '''
2997        self.port_override = port_override if port_override is not None else 0
2998        '''
2999
3000        '''
3001        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3002        '''
3003         ID of the secret store containing credentials for this resource, if any.
3004        '''
3005        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3006        '''
3007         Tags is a map of key, value pairs.
3008        '''
3009        self.username = username if username is not None else ''
3010        '''
3011
3012        '''
3013
3014    def __repr__(self):
3015        return '<sdm.AzurePostgres ' + \
3016            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3017            'database: ' + repr(self.database) + ' ' +\
3018            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3019            'healthy: ' + repr(self.healthy) + ' ' +\
3020            'hostname: ' + repr(self.hostname) + ' ' +\
3021            'id: ' + repr(self.id) + ' ' +\
3022            'name: ' + repr(self.name) + ' ' +\
3023            'override_database: ' + repr(self.override_database) + ' ' +\
3024            'password: ' + repr(self.password) + ' ' +\
3025            'port: ' + repr(self.port) + ' ' +\
3026            'port_override: ' + repr(self.port_override) + ' ' +\
3027            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3028            'tags: ' + repr(self.tags) + ' ' +\
3029            'username: ' + repr(self.username) + ' ' +\
3030            '>'
3031
3032    def to_dict(self):
3033        return {
3034            'bind_interface': self.bind_interface,
3035            'database': self.database,
3036            'egress_filter': self.egress_filter,
3037            'healthy': self.healthy,
3038            'hostname': self.hostname,
3039            'id': self.id,
3040            'name': self.name,
3041            'override_database': self.override_database,
3042            'password': self.password,
3043            'port': self.port,
3044            'port_override': self.port_override,
3045            'secret_store_id': self.secret_store_id,
3046            'tags': self.tags,
3047            'username': self.username,
3048        }
3049
3050    @classmethod
3051    def from_dict(cls, d):
3052        return cls(
3053            bind_interface=d.get('bind_interface'),
3054            database=d.get('database'),
3055            egress_filter=d.get('egress_filter'),
3056            healthy=d.get('healthy'),
3057            hostname=d.get('hostname'),
3058            id=d.get('id'),
3059            name=d.get('name'),
3060            override_database=d.get('override_database'),
3061            password=d.get('password'),
3062            port=d.get('port'),
3063            port_override=d.get('port_override'),
3064            secret_store_id=d.get('secret_store_id'),
3065            tags=d.get('tags'),
3066            username=d.get('username'),
3067        )
AzurePostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2940    def __init__(
2941        self,
2942        bind_interface=None,
2943        database=None,
2944        egress_filter=None,
2945        healthy=None,
2946        hostname=None,
2947        id=None,
2948        name=None,
2949        override_database=None,
2950        password=None,
2951        port=None,
2952        port_override=None,
2953        secret_store_id=None,
2954        tags=None,
2955        username=None,
2956    ):
2957        self.bind_interface = bind_interface if bind_interface is not None else ''
2958        '''
2959         Bind interface
2960        '''
2961        self.database = database if database is not None else ''
2962        '''
2963
2964        '''
2965        self.egress_filter = egress_filter if egress_filter is not None else ''
2966        '''
2967         A filter applied to the routing logic to pin datasource to nodes.
2968        '''
2969        self.healthy = healthy if healthy is not None else False
2970        '''
2971         True if the datasource is reachable and the credentials are valid.
2972        '''
2973        self.hostname = hostname if hostname is not None else ''
2974        '''
2975
2976        '''
2977        self.id = id if id is not None else ''
2978        '''
2979         Unique identifier of the Resource.
2980        '''
2981        self.name = name if name is not None else ''
2982        '''
2983         Unique human-readable name of the Resource.
2984        '''
2985        self.override_database = override_database if override_database is not None else False
2986        '''
2987
2988        '''
2989        self.password = password if password is not None else ''
2990        '''
2991
2992        '''
2993        self.port = port if port is not None else 0
2994        '''
2995
2996        '''
2997        self.port_override = port_override if port_override is not None else 0
2998        '''
2999
3000        '''
3001        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3002        '''
3003         ID of the secret store containing credentials for this resource, if any.
3004        '''
3005        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3006        '''
3007         Tags is a map of key, value pairs.
3008        '''
3009        self.username = username if username is not None else ''
3010        '''
3011
3012        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3032    def to_dict(self):
3033        return {
3034            'bind_interface': self.bind_interface,
3035            'database': self.database,
3036            'egress_filter': self.egress_filter,
3037            'healthy': self.healthy,
3038            'hostname': self.hostname,
3039            'id': self.id,
3040            'name': self.name,
3041            'override_database': self.override_database,
3042            'password': self.password,
3043            'port': self.port,
3044            'port_override': self.port_override,
3045            'secret_store_id': self.secret_store_id,
3046            'tags': self.tags,
3047            'username': self.username,
3048        }
@classmethod
def from_dict(cls, d)
3050    @classmethod
3051    def from_dict(cls, d):
3052        return cls(
3053            bind_interface=d.get('bind_interface'),
3054            database=d.get('database'),
3055            egress_filter=d.get('egress_filter'),
3056            healthy=d.get('healthy'),
3057            hostname=d.get('hostname'),
3058            id=d.get('id'),
3059            name=d.get('name'),
3060            override_database=d.get('override_database'),
3061            password=d.get('password'),
3062            port=d.get('port'),
3063            port_override=d.get('port_override'),
3064            secret_store_id=d.get('secret_store_id'),
3065            tags=d.get('tags'),
3066            username=d.get('username'),
3067        )
class AzureStore:
3070class AzureStore:
3071    '''
3072
3073    '''
3074    __slots__ = [
3075        'id',
3076        'name',
3077        'tags',
3078        'vault_uri',
3079    ]
3080
3081    def __init__(
3082        self,
3083        id=None,
3084        name=None,
3085        tags=None,
3086        vault_uri=None,
3087    ):
3088        self.id = id if id is not None else ''
3089        '''
3090         Unique identifier of the SecretStore.
3091        '''
3092        self.name = name if name is not None else ''
3093        '''
3094         Unique human-readable name of the SecretStore.
3095        '''
3096        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3097        '''
3098         Tags is a map of key, value pairs.
3099        '''
3100        self.vault_uri = vault_uri if vault_uri is not None else ''
3101        '''
3102
3103        '''
3104
3105    def __repr__(self):
3106        return '<sdm.AzureStore ' + \
3107            'id: ' + repr(self.id) + ' ' +\
3108            'name: ' + repr(self.name) + ' ' +\
3109            'tags: ' + repr(self.tags) + ' ' +\
3110            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
3111            '>'
3112
3113    def to_dict(self):
3114        return {
3115            'id': self.id,
3116            'name': self.name,
3117            'tags': self.tags,
3118            'vault_uri': self.vault_uri,
3119        }
3120
3121    @classmethod
3122    def from_dict(cls, d):
3123        return cls(
3124            id=d.get('id'),
3125            name=d.get('name'),
3126            tags=d.get('tags'),
3127            vault_uri=d.get('vault_uri'),
3128        )
AzureStore(id=None, name=None, tags=None, vault_uri=None)
3081    def __init__(
3082        self,
3083        id=None,
3084        name=None,
3085        tags=None,
3086        vault_uri=None,
3087    ):
3088        self.id = id if id is not None else ''
3089        '''
3090         Unique identifier of the SecretStore.
3091        '''
3092        self.name = name if name is not None else ''
3093        '''
3094         Unique human-readable name of the SecretStore.
3095        '''
3096        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3097        '''
3098         Tags is a map of key, value pairs.
3099        '''
3100        self.vault_uri = vault_uri if vault_uri is not None else ''
3101        '''
3102
3103        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

vault_uri
def to_dict(self)
3113    def to_dict(self):
3114        return {
3115            'id': self.id,
3116            'name': self.name,
3117            'tags': self.tags,
3118            'vault_uri': self.vault_uri,
3119        }
@classmethod
def from_dict(cls, d)
3121    @classmethod
3122    def from_dict(cls, d):
3123        return cls(
3124            id=d.get('id'),
3125            name=d.get('name'),
3126            tags=d.get('tags'),
3127            vault_uri=d.get('vault_uri'),
3128        )
class BigQuery:
3131class BigQuery:
3132    '''
3133
3134    '''
3135    __slots__ = [
3136        'bind_interface',
3137        'egress_filter',
3138        'endpoint',
3139        'healthy',
3140        'id',
3141        'name',
3142        'port_override',
3143        'private_key',
3144        'project',
3145        'secret_store_id',
3146        'tags',
3147        'username',
3148    ]
3149
3150    def __init__(
3151        self,
3152        bind_interface=None,
3153        egress_filter=None,
3154        endpoint=None,
3155        healthy=None,
3156        id=None,
3157        name=None,
3158        port_override=None,
3159        private_key=None,
3160        project=None,
3161        secret_store_id=None,
3162        tags=None,
3163        username=None,
3164    ):
3165        self.bind_interface = bind_interface if bind_interface is not None else ''
3166        '''
3167         Bind interface
3168        '''
3169        self.egress_filter = egress_filter if egress_filter is not None else ''
3170        '''
3171         A filter applied to the routing logic to pin datasource to nodes.
3172        '''
3173        self.endpoint = endpoint if endpoint is not None else ''
3174        '''
3175
3176        '''
3177        self.healthy = healthy if healthy is not None else False
3178        '''
3179         True if the datasource is reachable and the credentials are valid.
3180        '''
3181        self.id = id if id is not None else ''
3182        '''
3183         Unique identifier of the Resource.
3184        '''
3185        self.name = name if name is not None else ''
3186        '''
3187         Unique human-readable name of the Resource.
3188        '''
3189        self.port_override = port_override if port_override is not None else 0
3190        '''
3191
3192        '''
3193        self.private_key = private_key if private_key is not None else ''
3194        '''
3195
3196        '''
3197        self.project = project if project is not None else ''
3198        '''
3199
3200        '''
3201        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3202        '''
3203         ID of the secret store containing credentials for this resource, if any.
3204        '''
3205        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3206        '''
3207         Tags is a map of key, value pairs.
3208        '''
3209        self.username = username if username is not None else ''
3210        '''
3211
3212        '''
3213
3214    def __repr__(self):
3215        return '<sdm.BigQuery ' + \
3216            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3217            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3218            'endpoint: ' + repr(self.endpoint) + ' ' +\
3219            'healthy: ' + repr(self.healthy) + ' ' +\
3220            'id: ' + repr(self.id) + ' ' +\
3221            'name: ' + repr(self.name) + ' ' +\
3222            'port_override: ' + repr(self.port_override) + ' ' +\
3223            'private_key: ' + repr(self.private_key) + ' ' +\
3224            'project: ' + repr(self.project) + ' ' +\
3225            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3226            'tags: ' + repr(self.tags) + ' ' +\
3227            'username: ' + repr(self.username) + ' ' +\
3228            '>'
3229
3230    def to_dict(self):
3231        return {
3232            'bind_interface': self.bind_interface,
3233            'egress_filter': self.egress_filter,
3234            'endpoint': self.endpoint,
3235            'healthy': self.healthy,
3236            'id': self.id,
3237            'name': self.name,
3238            'port_override': self.port_override,
3239            'private_key': self.private_key,
3240            'project': self.project,
3241            'secret_store_id': self.secret_store_id,
3242            'tags': self.tags,
3243            'username': self.username,
3244        }
3245
3246    @classmethod
3247    def from_dict(cls, d):
3248        return cls(
3249            bind_interface=d.get('bind_interface'),
3250            egress_filter=d.get('egress_filter'),
3251            endpoint=d.get('endpoint'),
3252            healthy=d.get('healthy'),
3253            id=d.get('id'),
3254            name=d.get('name'),
3255            port_override=d.get('port_override'),
3256            private_key=d.get('private_key'),
3257            project=d.get('project'),
3258            secret_store_id=d.get('secret_store_id'),
3259            tags=d.get('tags'),
3260            username=d.get('username'),
3261        )
BigQuery( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, private_key=None, project=None, secret_store_id=None, tags=None, username=None)
3150    def __init__(
3151        self,
3152        bind_interface=None,
3153        egress_filter=None,
3154        endpoint=None,
3155        healthy=None,
3156        id=None,
3157        name=None,
3158        port_override=None,
3159        private_key=None,
3160        project=None,
3161        secret_store_id=None,
3162        tags=None,
3163        username=None,
3164    ):
3165        self.bind_interface = bind_interface if bind_interface is not None else ''
3166        '''
3167         Bind interface
3168        '''
3169        self.egress_filter = egress_filter if egress_filter is not None else ''
3170        '''
3171         A filter applied to the routing logic to pin datasource to nodes.
3172        '''
3173        self.endpoint = endpoint if endpoint is not None else ''
3174        '''
3175
3176        '''
3177        self.healthy = healthy if healthy is not None else False
3178        '''
3179         True if the datasource is reachable and the credentials are valid.
3180        '''
3181        self.id = id if id is not None else ''
3182        '''
3183         Unique identifier of the Resource.
3184        '''
3185        self.name = name if name is not None else ''
3186        '''
3187         Unique human-readable name of the Resource.
3188        '''
3189        self.port_override = port_override if port_override is not None else 0
3190        '''
3191
3192        '''
3193        self.private_key = private_key if private_key is not None else ''
3194        '''
3195
3196        '''
3197        self.project = project if project is not None else ''
3198        '''
3199
3200        '''
3201        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3202        '''
3203         ID of the secret store containing credentials for this resource, if any.
3204        '''
3205        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3206        '''
3207         Tags is a map of key, value pairs.
3208        '''
3209        self.username = username if username is not None else ''
3210        '''
3211
3212        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
private_key
project
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3230    def to_dict(self):
3231        return {
3232            'bind_interface': self.bind_interface,
3233            'egress_filter': self.egress_filter,
3234            'endpoint': self.endpoint,
3235            'healthy': self.healthy,
3236            'id': self.id,
3237            'name': self.name,
3238            'port_override': self.port_override,
3239            'private_key': self.private_key,
3240            'project': self.project,
3241            'secret_store_id': self.secret_store_id,
3242            'tags': self.tags,
3243            'username': self.username,
3244        }
@classmethod
def from_dict(cls, d)
3246    @classmethod
3247    def from_dict(cls, d):
3248        return cls(
3249            bind_interface=d.get('bind_interface'),
3250            egress_filter=d.get('egress_filter'),
3251            endpoint=d.get('endpoint'),
3252            healthy=d.get('healthy'),
3253            id=d.get('id'),
3254            name=d.get('name'),
3255            port_override=d.get('port_override'),
3256            private_key=d.get('private_key'),
3257            project=d.get('project'),
3258            secret_store_id=d.get('secret_store_id'),
3259            tags=d.get('tags'),
3260            username=d.get('username'),
3261        )
class Cassandra:
3264class Cassandra:
3265    '''
3266
3267    '''
3268    __slots__ = [
3269        'bind_interface',
3270        'egress_filter',
3271        'healthy',
3272        'hostname',
3273        'id',
3274        'name',
3275        'password',
3276        'port',
3277        'port_override',
3278        'secret_store_id',
3279        'tags',
3280        'tls_required',
3281        'username',
3282    ]
3283
3284    def __init__(
3285        self,
3286        bind_interface=None,
3287        egress_filter=None,
3288        healthy=None,
3289        hostname=None,
3290        id=None,
3291        name=None,
3292        password=None,
3293        port=None,
3294        port_override=None,
3295        secret_store_id=None,
3296        tags=None,
3297        tls_required=None,
3298        username=None,
3299    ):
3300        self.bind_interface = bind_interface if bind_interface is not None else ''
3301        '''
3302         Bind interface
3303        '''
3304        self.egress_filter = egress_filter if egress_filter is not None else ''
3305        '''
3306         A filter applied to the routing logic to pin datasource to nodes.
3307        '''
3308        self.healthy = healthy if healthy is not None else False
3309        '''
3310         True if the datasource is reachable and the credentials are valid.
3311        '''
3312        self.hostname = hostname if hostname is not None else ''
3313        '''
3314
3315        '''
3316        self.id = id if id is not None else ''
3317        '''
3318         Unique identifier of the Resource.
3319        '''
3320        self.name = name if name is not None else ''
3321        '''
3322         Unique human-readable name of the Resource.
3323        '''
3324        self.password = password if password is not None else ''
3325        '''
3326
3327        '''
3328        self.port = port if port is not None else 0
3329        '''
3330
3331        '''
3332        self.port_override = port_override if port_override is not None else 0
3333        '''
3334
3335        '''
3336        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3337        '''
3338         ID of the secret store containing credentials for this resource, if any.
3339        '''
3340        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3341        '''
3342         Tags is a map of key, value pairs.
3343        '''
3344        self.tls_required = tls_required if tls_required is not None else False
3345        '''
3346
3347        '''
3348        self.username = username if username is not None else ''
3349        '''
3350
3351        '''
3352
3353    def __repr__(self):
3354        return '<sdm.Cassandra ' + \
3355            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3356            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3357            'healthy: ' + repr(self.healthy) + ' ' +\
3358            'hostname: ' + repr(self.hostname) + ' ' +\
3359            'id: ' + repr(self.id) + ' ' +\
3360            'name: ' + repr(self.name) + ' ' +\
3361            'password: ' + repr(self.password) + ' ' +\
3362            'port: ' + repr(self.port) + ' ' +\
3363            'port_override: ' + repr(self.port_override) + ' ' +\
3364            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3365            'tags: ' + repr(self.tags) + ' ' +\
3366            'tls_required: ' + repr(self.tls_required) + ' ' +\
3367            'username: ' + repr(self.username) + ' ' +\
3368            '>'
3369
3370    def to_dict(self):
3371        return {
3372            'bind_interface': self.bind_interface,
3373            'egress_filter': self.egress_filter,
3374            'healthy': self.healthy,
3375            'hostname': self.hostname,
3376            'id': self.id,
3377            'name': self.name,
3378            'password': self.password,
3379            'port': self.port,
3380            'port_override': self.port_override,
3381            'secret_store_id': self.secret_store_id,
3382            'tags': self.tags,
3383            'tls_required': self.tls_required,
3384            'username': self.username,
3385        }
3386
3387    @classmethod
3388    def from_dict(cls, d):
3389        return cls(
3390            bind_interface=d.get('bind_interface'),
3391            egress_filter=d.get('egress_filter'),
3392            healthy=d.get('healthy'),
3393            hostname=d.get('hostname'),
3394            id=d.get('id'),
3395            name=d.get('name'),
3396            password=d.get('password'),
3397            port=d.get('port'),
3398            port_override=d.get('port_override'),
3399            secret_store_id=d.get('secret_store_id'),
3400            tags=d.get('tags'),
3401            tls_required=d.get('tls_required'),
3402            username=d.get('username'),
3403        )
Cassandra( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
3284    def __init__(
3285        self,
3286        bind_interface=None,
3287        egress_filter=None,
3288        healthy=None,
3289        hostname=None,
3290        id=None,
3291        name=None,
3292        password=None,
3293        port=None,
3294        port_override=None,
3295        secret_store_id=None,
3296        tags=None,
3297        tls_required=None,
3298        username=None,
3299    ):
3300        self.bind_interface = bind_interface if bind_interface is not None else ''
3301        '''
3302         Bind interface
3303        '''
3304        self.egress_filter = egress_filter if egress_filter is not None else ''
3305        '''
3306         A filter applied to the routing logic to pin datasource to nodes.
3307        '''
3308        self.healthy = healthy if healthy is not None else False
3309        '''
3310         True if the datasource is reachable and the credentials are valid.
3311        '''
3312        self.hostname = hostname if hostname is not None else ''
3313        '''
3314
3315        '''
3316        self.id = id if id is not None else ''
3317        '''
3318         Unique identifier of the Resource.
3319        '''
3320        self.name = name if name is not None else ''
3321        '''
3322         Unique human-readable name of the Resource.
3323        '''
3324        self.password = password if password is not None else ''
3325        '''
3326
3327        '''
3328        self.port = port if port is not None else 0
3329        '''
3330
3331        '''
3332        self.port_override = port_override if port_override is not None else 0
3333        '''
3334
3335        '''
3336        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3337        '''
3338         ID of the secret store containing credentials for this resource, if any.
3339        '''
3340        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3341        '''
3342         Tags is a map of key, value pairs.
3343        '''
3344        self.tls_required = tls_required if tls_required is not None else False
3345        '''
3346
3347        '''
3348        self.username = username if username is not None else ''
3349        '''
3350
3351        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
3370    def to_dict(self):
3371        return {
3372            'bind_interface': self.bind_interface,
3373            'egress_filter': self.egress_filter,
3374            'healthy': self.healthy,
3375            'hostname': self.hostname,
3376            'id': self.id,
3377            'name': self.name,
3378            'password': self.password,
3379            'port': self.port,
3380            'port_override': self.port_override,
3381            'secret_store_id': self.secret_store_id,
3382            'tags': self.tags,
3383            'tls_required': self.tls_required,
3384            'username': self.username,
3385        }
@classmethod
def from_dict(cls, d)
3387    @classmethod
3388    def from_dict(cls, d):
3389        return cls(
3390            bind_interface=d.get('bind_interface'),
3391            egress_filter=d.get('egress_filter'),
3392            healthy=d.get('healthy'),
3393            hostname=d.get('hostname'),
3394            id=d.get('id'),
3395            name=d.get('name'),
3396            password=d.get('password'),
3397            port=d.get('port'),
3398            port_override=d.get('port_override'),
3399            secret_store_id=d.get('secret_store_id'),
3400            tags=d.get('tags'),
3401            tls_required=d.get('tls_required'),
3402            username=d.get('username'),
3403        )
class Citus:
3406class Citus:
3407    '''
3408
3409    '''
3410    __slots__ = [
3411        'bind_interface',
3412        'database',
3413        'egress_filter',
3414        'healthy',
3415        'hostname',
3416        'id',
3417        'name',
3418        'override_database',
3419        'password',
3420        'port',
3421        'port_override',
3422        'secret_store_id',
3423        'tags',
3424        'username',
3425    ]
3426
3427    def __init__(
3428        self,
3429        bind_interface=None,
3430        database=None,
3431        egress_filter=None,
3432        healthy=None,
3433        hostname=None,
3434        id=None,
3435        name=None,
3436        override_database=None,
3437        password=None,
3438        port=None,
3439        port_override=None,
3440        secret_store_id=None,
3441        tags=None,
3442        username=None,
3443    ):
3444        self.bind_interface = bind_interface if bind_interface is not None else ''
3445        '''
3446         Bind interface
3447        '''
3448        self.database = database if database is not None else ''
3449        '''
3450
3451        '''
3452        self.egress_filter = egress_filter if egress_filter is not None else ''
3453        '''
3454         A filter applied to the routing logic to pin datasource to nodes.
3455        '''
3456        self.healthy = healthy if healthy is not None else False
3457        '''
3458         True if the datasource is reachable and the credentials are valid.
3459        '''
3460        self.hostname = hostname if hostname is not None else ''
3461        '''
3462
3463        '''
3464        self.id = id if id is not None else ''
3465        '''
3466         Unique identifier of the Resource.
3467        '''
3468        self.name = name if name is not None else ''
3469        '''
3470         Unique human-readable name of the Resource.
3471        '''
3472        self.override_database = override_database if override_database is not None else False
3473        '''
3474
3475        '''
3476        self.password = password if password is not None else ''
3477        '''
3478
3479        '''
3480        self.port = port if port is not None else 0
3481        '''
3482
3483        '''
3484        self.port_override = port_override if port_override is not None else 0
3485        '''
3486
3487        '''
3488        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3489        '''
3490         ID of the secret store containing credentials for this resource, if any.
3491        '''
3492        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3493        '''
3494         Tags is a map of key, value pairs.
3495        '''
3496        self.username = username if username is not None else ''
3497        '''
3498
3499        '''
3500
3501    def __repr__(self):
3502        return '<sdm.Citus ' + \
3503            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3504            'database: ' + repr(self.database) + ' ' +\
3505            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3506            'healthy: ' + repr(self.healthy) + ' ' +\
3507            'hostname: ' + repr(self.hostname) + ' ' +\
3508            'id: ' + repr(self.id) + ' ' +\
3509            'name: ' + repr(self.name) + ' ' +\
3510            'override_database: ' + repr(self.override_database) + ' ' +\
3511            'password: ' + repr(self.password) + ' ' +\
3512            'port: ' + repr(self.port) + ' ' +\
3513            'port_override: ' + repr(self.port_override) + ' ' +\
3514            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3515            'tags: ' + repr(self.tags) + ' ' +\
3516            'username: ' + repr(self.username) + ' ' +\
3517            '>'
3518
3519    def to_dict(self):
3520        return {
3521            'bind_interface': self.bind_interface,
3522            'database': self.database,
3523            'egress_filter': self.egress_filter,
3524            'healthy': self.healthy,
3525            'hostname': self.hostname,
3526            'id': self.id,
3527            'name': self.name,
3528            'override_database': self.override_database,
3529            'password': self.password,
3530            'port': self.port,
3531            'port_override': self.port_override,
3532            'secret_store_id': self.secret_store_id,
3533            'tags': self.tags,
3534            'username': self.username,
3535        }
3536
3537    @classmethod
3538    def from_dict(cls, d):
3539        return cls(
3540            bind_interface=d.get('bind_interface'),
3541            database=d.get('database'),
3542            egress_filter=d.get('egress_filter'),
3543            healthy=d.get('healthy'),
3544            hostname=d.get('hostname'),
3545            id=d.get('id'),
3546            name=d.get('name'),
3547            override_database=d.get('override_database'),
3548            password=d.get('password'),
3549            port=d.get('port'),
3550            port_override=d.get('port_override'),
3551            secret_store_id=d.get('secret_store_id'),
3552            tags=d.get('tags'),
3553            username=d.get('username'),
3554        )
Citus( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3427    def __init__(
3428        self,
3429        bind_interface=None,
3430        database=None,
3431        egress_filter=None,
3432        healthy=None,
3433        hostname=None,
3434        id=None,
3435        name=None,
3436        override_database=None,
3437        password=None,
3438        port=None,
3439        port_override=None,
3440        secret_store_id=None,
3441        tags=None,
3442        username=None,
3443    ):
3444        self.bind_interface = bind_interface if bind_interface is not None else ''
3445        '''
3446         Bind interface
3447        '''
3448        self.database = database if database is not None else ''
3449        '''
3450
3451        '''
3452        self.egress_filter = egress_filter if egress_filter is not None else ''
3453        '''
3454         A filter applied to the routing logic to pin datasource to nodes.
3455        '''
3456        self.healthy = healthy if healthy is not None else False
3457        '''
3458         True if the datasource is reachable and the credentials are valid.
3459        '''
3460        self.hostname = hostname if hostname is not None else ''
3461        '''
3462
3463        '''
3464        self.id = id if id is not None else ''
3465        '''
3466         Unique identifier of the Resource.
3467        '''
3468        self.name = name if name is not None else ''
3469        '''
3470         Unique human-readable name of the Resource.
3471        '''
3472        self.override_database = override_database if override_database is not None else False
3473        '''
3474
3475        '''
3476        self.password = password if password is not None else ''
3477        '''
3478
3479        '''
3480        self.port = port if port is not None else 0
3481        '''
3482
3483        '''
3484        self.port_override = port_override if port_override is not None else 0
3485        '''
3486
3487        '''
3488        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3489        '''
3490         ID of the secret store containing credentials for this resource, if any.
3491        '''
3492        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3493        '''
3494         Tags is a map of key, value pairs.
3495        '''
3496        self.username = username if username is not None else ''
3497        '''
3498
3499        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3519    def to_dict(self):
3520        return {
3521            'bind_interface': self.bind_interface,
3522            'database': self.database,
3523            'egress_filter': self.egress_filter,
3524            'healthy': self.healthy,
3525            'hostname': self.hostname,
3526            'id': self.id,
3527            'name': self.name,
3528            'override_database': self.override_database,
3529            'password': self.password,
3530            'port': self.port,
3531            'port_override': self.port_override,
3532            'secret_store_id': self.secret_store_id,
3533            'tags': self.tags,
3534            'username': self.username,
3535        }
@classmethod
def from_dict(cls, d)
3537    @classmethod
3538    def from_dict(cls, d):
3539        return cls(
3540            bind_interface=d.get('bind_interface'),
3541            database=d.get('database'),
3542            egress_filter=d.get('egress_filter'),
3543            healthy=d.get('healthy'),
3544            hostname=d.get('hostname'),
3545            id=d.get('id'),
3546            name=d.get('name'),
3547            override_database=d.get('override_database'),
3548            password=d.get('password'),
3549            port=d.get('port'),
3550            port_override=d.get('port_override'),
3551            secret_store_id=d.get('secret_store_id'),
3552            tags=d.get('tags'),
3553            username=d.get('username'),
3554        )
class Clustrix:
3557class Clustrix:
3558    '''
3559
3560    '''
3561    __slots__ = [
3562        'bind_interface',
3563        'database',
3564        'egress_filter',
3565        'healthy',
3566        'hostname',
3567        'id',
3568        'name',
3569        'password',
3570        'port',
3571        'port_override',
3572        'secret_store_id',
3573        'tags',
3574        'username',
3575    ]
3576
3577    def __init__(
3578        self,
3579        bind_interface=None,
3580        database=None,
3581        egress_filter=None,
3582        healthy=None,
3583        hostname=None,
3584        id=None,
3585        name=None,
3586        password=None,
3587        port=None,
3588        port_override=None,
3589        secret_store_id=None,
3590        tags=None,
3591        username=None,
3592    ):
3593        self.bind_interface = bind_interface if bind_interface is not None else ''
3594        '''
3595         Bind interface
3596        '''
3597        self.database = database if database is not None else ''
3598        '''
3599
3600        '''
3601        self.egress_filter = egress_filter if egress_filter is not None else ''
3602        '''
3603         A filter applied to the routing logic to pin datasource to nodes.
3604        '''
3605        self.healthy = healthy if healthy is not None else False
3606        '''
3607         True if the datasource is reachable and the credentials are valid.
3608        '''
3609        self.hostname = hostname if hostname is not None else ''
3610        '''
3611
3612        '''
3613        self.id = id if id is not None else ''
3614        '''
3615         Unique identifier of the Resource.
3616        '''
3617        self.name = name if name is not None else ''
3618        '''
3619         Unique human-readable name of the Resource.
3620        '''
3621        self.password = password if password is not None else ''
3622        '''
3623
3624        '''
3625        self.port = port if port is not None else 0
3626        '''
3627
3628        '''
3629        self.port_override = port_override if port_override is not None else 0
3630        '''
3631
3632        '''
3633        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3634        '''
3635         ID of the secret store containing credentials for this resource, if any.
3636        '''
3637        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3638        '''
3639         Tags is a map of key, value pairs.
3640        '''
3641        self.username = username if username is not None else ''
3642        '''
3643
3644        '''
3645
3646    def __repr__(self):
3647        return '<sdm.Clustrix ' + \
3648            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3649            'database: ' + repr(self.database) + ' ' +\
3650            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3651            'healthy: ' + repr(self.healthy) + ' ' +\
3652            'hostname: ' + repr(self.hostname) + ' ' +\
3653            'id: ' + repr(self.id) + ' ' +\
3654            'name: ' + repr(self.name) + ' ' +\
3655            'password: ' + repr(self.password) + ' ' +\
3656            'port: ' + repr(self.port) + ' ' +\
3657            'port_override: ' + repr(self.port_override) + ' ' +\
3658            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3659            'tags: ' + repr(self.tags) + ' ' +\
3660            'username: ' + repr(self.username) + ' ' +\
3661            '>'
3662
3663    def to_dict(self):
3664        return {
3665            'bind_interface': self.bind_interface,
3666            'database': self.database,
3667            'egress_filter': self.egress_filter,
3668            'healthy': self.healthy,
3669            'hostname': self.hostname,
3670            'id': self.id,
3671            'name': self.name,
3672            'password': self.password,
3673            'port': self.port,
3674            'port_override': self.port_override,
3675            'secret_store_id': self.secret_store_id,
3676            'tags': self.tags,
3677            'username': self.username,
3678        }
3679
3680    @classmethod
3681    def from_dict(cls, d):
3682        return cls(
3683            bind_interface=d.get('bind_interface'),
3684            database=d.get('database'),
3685            egress_filter=d.get('egress_filter'),
3686            healthy=d.get('healthy'),
3687            hostname=d.get('hostname'),
3688            id=d.get('id'),
3689            name=d.get('name'),
3690            password=d.get('password'),
3691            port=d.get('port'),
3692            port_override=d.get('port_override'),
3693            secret_store_id=d.get('secret_store_id'),
3694            tags=d.get('tags'),
3695            username=d.get('username'),
3696        )
Clustrix( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3577    def __init__(
3578        self,
3579        bind_interface=None,
3580        database=None,
3581        egress_filter=None,
3582        healthy=None,
3583        hostname=None,
3584        id=None,
3585        name=None,
3586        password=None,
3587        port=None,
3588        port_override=None,
3589        secret_store_id=None,
3590        tags=None,
3591        username=None,
3592    ):
3593        self.bind_interface = bind_interface if bind_interface is not None else ''
3594        '''
3595         Bind interface
3596        '''
3597        self.database = database if database is not None else ''
3598        '''
3599
3600        '''
3601        self.egress_filter = egress_filter if egress_filter is not None else ''
3602        '''
3603         A filter applied to the routing logic to pin datasource to nodes.
3604        '''
3605        self.healthy = healthy if healthy is not None else False
3606        '''
3607         True if the datasource is reachable and the credentials are valid.
3608        '''
3609        self.hostname = hostname if hostname is not None else ''
3610        '''
3611
3612        '''
3613        self.id = id if id is not None else ''
3614        '''
3615         Unique identifier of the Resource.
3616        '''
3617        self.name = name if name is not None else ''
3618        '''
3619         Unique human-readable name of the Resource.
3620        '''
3621        self.password = password if password is not None else ''
3622        '''
3623
3624        '''
3625        self.port = port if port is not None else 0
3626        '''
3627
3628        '''
3629        self.port_override = port_override if port_override is not None else 0
3630        '''
3631
3632        '''
3633        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3634        '''
3635         ID of the secret store containing credentials for this resource, if any.
3636        '''
3637        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3638        '''
3639         Tags is a map of key, value pairs.
3640        '''
3641        self.username = username if username is not None else ''
3642        '''
3643
3644        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3663    def to_dict(self):
3664        return {
3665            'bind_interface': self.bind_interface,
3666            'database': self.database,
3667            'egress_filter': self.egress_filter,
3668            'healthy': self.healthy,
3669            'hostname': self.hostname,
3670            'id': self.id,
3671            'name': self.name,
3672            'password': self.password,
3673            'port': self.port,
3674            'port_override': self.port_override,
3675            'secret_store_id': self.secret_store_id,
3676            'tags': self.tags,
3677            'username': self.username,
3678        }
@classmethod
def from_dict(cls, d)
3680    @classmethod
3681    def from_dict(cls, d):
3682        return cls(
3683            bind_interface=d.get('bind_interface'),
3684            database=d.get('database'),
3685            egress_filter=d.get('egress_filter'),
3686            healthy=d.get('healthy'),
3687            hostname=d.get('hostname'),
3688            id=d.get('id'),
3689            name=d.get('name'),
3690            password=d.get('password'),
3691            port=d.get('port'),
3692            port_override=d.get('port_override'),
3693            secret_store_id=d.get('secret_store_id'),
3694            tags=d.get('tags'),
3695            username=d.get('username'),
3696        )
class Cockroach:
3699class Cockroach:
3700    '''
3701
3702    '''
3703    __slots__ = [
3704        'bind_interface',
3705        'database',
3706        'egress_filter',
3707        'healthy',
3708        'hostname',
3709        'id',
3710        'name',
3711        'override_database',
3712        'password',
3713        'port',
3714        'port_override',
3715        'secret_store_id',
3716        'tags',
3717        'username',
3718    ]
3719
3720    def __init__(
3721        self,
3722        bind_interface=None,
3723        database=None,
3724        egress_filter=None,
3725        healthy=None,
3726        hostname=None,
3727        id=None,
3728        name=None,
3729        override_database=None,
3730        password=None,
3731        port=None,
3732        port_override=None,
3733        secret_store_id=None,
3734        tags=None,
3735        username=None,
3736    ):
3737        self.bind_interface = bind_interface if bind_interface is not None else ''
3738        '''
3739         Bind interface
3740        '''
3741        self.database = database if database is not None else ''
3742        '''
3743
3744        '''
3745        self.egress_filter = egress_filter if egress_filter is not None else ''
3746        '''
3747         A filter applied to the routing logic to pin datasource to nodes.
3748        '''
3749        self.healthy = healthy if healthy is not None else False
3750        '''
3751         True if the datasource is reachable and the credentials are valid.
3752        '''
3753        self.hostname = hostname if hostname is not None else ''
3754        '''
3755
3756        '''
3757        self.id = id if id is not None else ''
3758        '''
3759         Unique identifier of the Resource.
3760        '''
3761        self.name = name if name is not None else ''
3762        '''
3763         Unique human-readable name of the Resource.
3764        '''
3765        self.override_database = override_database if override_database is not None else False
3766        '''
3767
3768        '''
3769        self.password = password if password is not None else ''
3770        '''
3771
3772        '''
3773        self.port = port if port is not None else 0
3774        '''
3775
3776        '''
3777        self.port_override = port_override if port_override is not None else 0
3778        '''
3779
3780        '''
3781        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3782        '''
3783         ID of the secret store containing credentials for this resource, if any.
3784        '''
3785        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3786        '''
3787         Tags is a map of key, value pairs.
3788        '''
3789        self.username = username if username is not None else ''
3790        '''
3791
3792        '''
3793
3794    def __repr__(self):
3795        return '<sdm.Cockroach ' + \
3796            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3797            'database: ' + repr(self.database) + ' ' +\
3798            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3799            'healthy: ' + repr(self.healthy) + ' ' +\
3800            'hostname: ' + repr(self.hostname) + ' ' +\
3801            'id: ' + repr(self.id) + ' ' +\
3802            'name: ' + repr(self.name) + ' ' +\
3803            'override_database: ' + repr(self.override_database) + ' ' +\
3804            'password: ' + repr(self.password) + ' ' +\
3805            'port: ' + repr(self.port) + ' ' +\
3806            'port_override: ' + repr(self.port_override) + ' ' +\
3807            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3808            'tags: ' + repr(self.tags) + ' ' +\
3809            'username: ' + repr(self.username) + ' ' +\
3810            '>'
3811
3812    def to_dict(self):
3813        return {
3814            'bind_interface': self.bind_interface,
3815            'database': self.database,
3816            'egress_filter': self.egress_filter,
3817            'healthy': self.healthy,
3818            'hostname': self.hostname,
3819            'id': self.id,
3820            'name': self.name,
3821            'override_database': self.override_database,
3822            'password': self.password,
3823            'port': self.port,
3824            'port_override': self.port_override,
3825            'secret_store_id': self.secret_store_id,
3826            'tags': self.tags,
3827            'username': self.username,
3828        }
3829
3830    @classmethod
3831    def from_dict(cls, d):
3832        return cls(
3833            bind_interface=d.get('bind_interface'),
3834            database=d.get('database'),
3835            egress_filter=d.get('egress_filter'),
3836            healthy=d.get('healthy'),
3837            hostname=d.get('hostname'),
3838            id=d.get('id'),
3839            name=d.get('name'),
3840            override_database=d.get('override_database'),
3841            password=d.get('password'),
3842            port=d.get('port'),
3843            port_override=d.get('port_override'),
3844            secret_store_id=d.get('secret_store_id'),
3845            tags=d.get('tags'),
3846            username=d.get('username'),
3847        )
Cockroach( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3720    def __init__(
3721        self,
3722        bind_interface=None,
3723        database=None,
3724        egress_filter=None,
3725        healthy=None,
3726        hostname=None,
3727        id=None,
3728        name=None,
3729        override_database=None,
3730        password=None,
3731        port=None,
3732        port_override=None,
3733        secret_store_id=None,
3734        tags=None,
3735        username=None,
3736    ):
3737        self.bind_interface = bind_interface if bind_interface is not None else ''
3738        '''
3739         Bind interface
3740        '''
3741        self.database = database if database is not None else ''
3742        '''
3743
3744        '''
3745        self.egress_filter = egress_filter if egress_filter is not None else ''
3746        '''
3747         A filter applied to the routing logic to pin datasource to nodes.
3748        '''
3749        self.healthy = healthy if healthy is not None else False
3750        '''
3751         True if the datasource is reachable and the credentials are valid.
3752        '''
3753        self.hostname = hostname if hostname is not None else ''
3754        '''
3755
3756        '''
3757        self.id = id if id is not None else ''
3758        '''
3759         Unique identifier of the Resource.
3760        '''
3761        self.name = name if name is not None else ''
3762        '''
3763         Unique human-readable name of the Resource.
3764        '''
3765        self.override_database = override_database if override_database is not None else False
3766        '''
3767
3768        '''
3769        self.password = password if password is not None else ''
3770        '''
3771
3772        '''
3773        self.port = port if port is not None else 0
3774        '''
3775
3776        '''
3777        self.port_override = port_override if port_override is not None else 0
3778        '''
3779
3780        '''
3781        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3782        '''
3783         ID of the secret store containing credentials for this resource, if any.
3784        '''
3785        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3786        '''
3787         Tags is a map of key, value pairs.
3788        '''
3789        self.username = username if username is not None else ''
3790        '''
3791
3792        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3812    def to_dict(self):
3813        return {
3814            'bind_interface': self.bind_interface,
3815            'database': self.database,
3816            'egress_filter': self.egress_filter,
3817            'healthy': self.healthy,
3818            'hostname': self.hostname,
3819            'id': self.id,
3820            'name': self.name,
3821            'override_database': self.override_database,
3822            'password': self.password,
3823            'port': self.port,
3824            'port_override': self.port_override,
3825            'secret_store_id': self.secret_store_id,
3826            'tags': self.tags,
3827            'username': self.username,
3828        }
@classmethod
def from_dict(cls, d)
3830    @classmethod
3831    def from_dict(cls, d):
3832        return cls(
3833            bind_interface=d.get('bind_interface'),
3834            database=d.get('database'),
3835            egress_filter=d.get('egress_filter'),
3836            healthy=d.get('healthy'),
3837            hostname=d.get('hostname'),
3838            id=d.get('id'),
3839            name=d.get('name'),
3840            override_database=d.get('override_database'),
3841            password=d.get('password'),
3842            port=d.get('port'),
3843            port_override=d.get('port_override'),
3844            secret_store_id=d.get('secret_store_id'),
3845            tags=d.get('tags'),
3846            username=d.get('username'),
3847        )
class ControlPanelGetSSHCAPublicKeyResponse:
3850class ControlPanelGetSSHCAPublicKeyResponse:
3851    '''
3852     ControlPanelGetSSHCAPublicKeyResponse represents a request for an
3853     organization's SSH Certificate Authority public key.
3854    '''
3855    __slots__ = [
3856        'meta',
3857        'public_key',
3858        'rate_limit',
3859    ]
3860
3861    def __init__(
3862        self,
3863        meta=None,
3864        public_key=None,
3865        rate_limit=None,
3866    ):
3867        self.meta = meta if meta is not None else None
3868        '''
3869         Reserved for future use.
3870        '''
3871        self.public_key = public_key if public_key is not None else ''
3872        '''
3873         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3874         key format.
3875        '''
3876        self.rate_limit = rate_limit if rate_limit is not None else None
3877        '''
3878         Rate limit information.
3879        '''
3880
3881    def __repr__(self):
3882        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
3883            'meta: ' + repr(self.meta) + ' ' +\
3884            'public_key: ' + repr(self.public_key) + ' ' +\
3885            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3886            '>'
3887
3888    def to_dict(self):
3889        return {
3890            'meta': self.meta,
3891            'public_key': self.public_key,
3892            'rate_limit': self.rate_limit,
3893        }
3894
3895    @classmethod
3896    def from_dict(cls, d):
3897        return cls(
3898            meta=d.get('meta'),
3899            public_key=d.get('public_key'),
3900            rate_limit=d.get('rate_limit'),
3901        )

ControlPanelGetSSHCAPublicKeyResponse represents a request for an organization's SSH Certificate Authority public key.

ControlPanelGetSSHCAPublicKeyResponse(meta=None, public_key=None, rate_limit=None)
3861    def __init__(
3862        self,
3863        meta=None,
3864        public_key=None,
3865        rate_limit=None,
3866    ):
3867        self.meta = meta if meta is not None else None
3868        '''
3869         Reserved for future use.
3870        '''
3871        self.public_key = public_key if public_key is not None else ''
3872        '''
3873         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3874         key format.
3875        '''
3876        self.rate_limit = rate_limit if rate_limit is not None else None
3877        '''
3878         Rate limit information.
3879        '''
meta

Reserved for future use.

public_key

The public key of the SSH Certificate Authority, in OpenSSH RSA public key format.

rate_limit

Rate limit information.

def to_dict(self)
3888    def to_dict(self):
3889        return {
3890            'meta': self.meta,
3891            'public_key': self.public_key,
3892            'rate_limit': self.rate_limit,
3893        }
@classmethod
def from_dict(cls, d)
3895    @classmethod
3896    def from_dict(cls, d):
3897        return cls(
3898            meta=d.get('meta'),
3899            public_key=d.get('public_key'),
3900            rate_limit=d.get('rate_limit'),
3901        )
class ControlPanelVerifyJWTResponse:
3904class ControlPanelVerifyJWTResponse:
3905    '''
3906     ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
3907    '''
3908    __slots__ = [
3909        'meta',
3910        'rate_limit',
3911        'valid',
3912    ]
3913
3914    def __init__(
3915        self,
3916        meta=None,
3917        rate_limit=None,
3918        valid=None,
3919    ):
3920        self.meta = meta if meta is not None else None
3921        '''
3922         Reserved for future use.
3923        '''
3924        self.rate_limit = rate_limit if rate_limit is not None else None
3925        '''
3926         Rate limit information.
3927        '''
3928        self.valid = valid if valid is not None else False
3929        '''
3930         Reports if the given token is valid.
3931        '''
3932
3933    def __repr__(self):
3934        return '<sdm.ControlPanelVerifyJWTResponse ' + \
3935            'meta: ' + repr(self.meta) + ' ' +\
3936            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3937            'valid: ' + repr(self.valid) + ' ' +\
3938            '>'
3939
3940    def to_dict(self):
3941        return {
3942            'meta': self.meta,
3943            'rate_limit': self.rate_limit,
3944            'valid': self.valid,
3945        }
3946
3947    @classmethod
3948    def from_dict(cls, d):
3949        return cls(
3950            meta=d.get('meta'),
3951            rate_limit=d.get('rate_limit'),
3952            valid=d.get('valid'),
3953        )

ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.

ControlPanelVerifyJWTResponse(meta=None, rate_limit=None, valid=None)
3914    def __init__(
3915        self,
3916        meta=None,
3917        rate_limit=None,
3918        valid=None,
3919    ):
3920        self.meta = meta if meta is not None else None
3921        '''
3922         Reserved for future use.
3923        '''
3924        self.rate_limit = rate_limit if rate_limit is not None else None
3925        '''
3926         Rate limit information.
3927        '''
3928        self.valid = valid if valid is not None else False
3929        '''
3930         Reports if the given token is valid.
3931        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

valid

Reports if the given token is valid.

def to_dict(self)
3940    def to_dict(self):
3941        return {
3942            'meta': self.meta,
3943            'rate_limit': self.rate_limit,
3944            'valid': self.valid,
3945        }
@classmethod
def from_dict(cls, d)
3947    @classmethod
3948    def from_dict(cls, d):
3949        return cls(
3950            meta=d.get('meta'),
3951            rate_limit=d.get('rate_limit'),
3952            valid=d.get('valid'),
3953        )
class CreateResponseMetadata:
3956class CreateResponseMetadata:
3957    '''
3958     CreateResponseMetadata is reserved for future use.
3959    '''
3960    __slots__ = []
3961
3962    def __init__(self, ):
3963        pass
3964
3965    def __repr__(self):
3966        return '<sdm.CreateResponseMetadata ' + \
3967            '>'
3968
3969    def to_dict(self):
3970        return {}
3971
3972    @classmethod
3973    def from_dict(cls, d):
3974        return cls()

CreateResponseMetadata is reserved for future use.

CreateResponseMetadata()
3962    def __init__(self, ):
3963        pass
def to_dict(self)
3969    def to_dict(self):
3970        return {}
@classmethod
def from_dict(cls, d)
3972    @classmethod
3973    def from_dict(cls, d):
3974        return cls()
class DB2I:
3977class DB2I:
3978    '''
3979
3980    '''
3981    __slots__ = [
3982        'bind_interface',
3983        'egress_filter',
3984        'healthy',
3985        'hostname',
3986        'id',
3987        'name',
3988        'password',
3989        'port',
3990        'port_override',
3991        'secret_store_id',
3992        'tags',
3993        'tls_required',
3994        'username',
3995    ]
3996
3997    def __init__(
3998        self,
3999        bind_interface=None,
4000        egress_filter=None,
4001        healthy=None,
4002        hostname=None,
4003        id=None,
4004        name=None,
4005        password=None,
4006        port=None,
4007        port_override=None,
4008        secret_store_id=None,
4009        tags=None,
4010        tls_required=None,
4011        username=None,
4012    ):
4013        self.bind_interface = bind_interface if bind_interface is not None else ''
4014        '''
4015         Bind interface
4016        '''
4017        self.egress_filter = egress_filter if egress_filter is not None else ''
4018        '''
4019         A filter applied to the routing logic to pin datasource to nodes.
4020        '''
4021        self.healthy = healthy if healthy is not None else False
4022        '''
4023         True if the datasource is reachable and the credentials are valid.
4024        '''
4025        self.hostname = hostname if hostname is not None else ''
4026        '''
4027
4028        '''
4029        self.id = id if id is not None else ''
4030        '''
4031         Unique identifier of the Resource.
4032        '''
4033        self.name = name if name is not None else ''
4034        '''
4035         Unique human-readable name of the Resource.
4036        '''
4037        self.password = password if password is not None else ''
4038        '''
4039
4040        '''
4041        self.port = port if port is not None else 0
4042        '''
4043
4044        '''
4045        self.port_override = port_override if port_override is not None else 0
4046        '''
4047
4048        '''
4049        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4050        '''
4051         ID of the secret store containing credentials for this resource, if any.
4052        '''
4053        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4054        '''
4055         Tags is a map of key, value pairs.
4056        '''
4057        self.tls_required = tls_required if tls_required is not None else False
4058        '''
4059
4060        '''
4061        self.username = username if username is not None else ''
4062        '''
4063
4064        '''
4065
4066    def __repr__(self):
4067        return '<sdm.DB2I ' + \
4068            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4069            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4070            'healthy: ' + repr(self.healthy) + ' ' +\
4071            'hostname: ' + repr(self.hostname) + ' ' +\
4072            'id: ' + repr(self.id) + ' ' +\
4073            'name: ' + repr(self.name) + ' ' +\
4074            'password: ' + repr(self.password) + ' ' +\
4075            'port: ' + repr(self.port) + ' ' +\
4076            'port_override: ' + repr(self.port_override) + ' ' +\
4077            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4078            'tags: ' + repr(self.tags) + ' ' +\
4079            'tls_required: ' + repr(self.tls_required) + ' ' +\
4080            'username: ' + repr(self.username) + ' ' +\
4081            '>'
4082
4083    def to_dict(self):
4084        return {
4085            'bind_interface': self.bind_interface,
4086            'egress_filter': self.egress_filter,
4087            'healthy': self.healthy,
4088            'hostname': self.hostname,
4089            'id': self.id,
4090            'name': self.name,
4091            'password': self.password,
4092            'port': self.port,
4093            'port_override': self.port_override,
4094            'secret_store_id': self.secret_store_id,
4095            'tags': self.tags,
4096            'tls_required': self.tls_required,
4097            'username': self.username,
4098        }
4099
4100    @classmethod
4101    def from_dict(cls, d):
4102        return cls(
4103            bind_interface=d.get('bind_interface'),
4104            egress_filter=d.get('egress_filter'),
4105            healthy=d.get('healthy'),
4106            hostname=d.get('hostname'),
4107            id=d.get('id'),
4108            name=d.get('name'),
4109            password=d.get('password'),
4110            port=d.get('port'),
4111            port_override=d.get('port_override'),
4112            secret_store_id=d.get('secret_store_id'),
4113            tags=d.get('tags'),
4114            tls_required=d.get('tls_required'),
4115            username=d.get('username'),
4116        )
DB2I( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
3997    def __init__(
3998        self,
3999        bind_interface=None,
4000        egress_filter=None,
4001        healthy=None,
4002        hostname=None,
4003        id=None,
4004        name=None,
4005        password=None,
4006        port=None,
4007        port_override=None,
4008        secret_store_id=None,
4009        tags=None,
4010        tls_required=None,
4011        username=None,
4012    ):
4013        self.bind_interface = bind_interface if bind_interface is not None else ''
4014        '''
4015         Bind interface
4016        '''
4017        self.egress_filter = egress_filter if egress_filter is not None else ''
4018        '''
4019         A filter applied to the routing logic to pin datasource to nodes.
4020        '''
4021        self.healthy = healthy if healthy is not None else False
4022        '''
4023         True if the datasource is reachable and the credentials are valid.
4024        '''
4025        self.hostname = hostname if hostname is not None else ''
4026        '''
4027
4028        '''
4029        self.id = id if id is not None else ''
4030        '''
4031         Unique identifier of the Resource.
4032        '''
4033        self.name = name if name is not None else ''
4034        '''
4035         Unique human-readable name of the Resource.
4036        '''
4037        self.password = password if password is not None else ''
4038        '''
4039
4040        '''
4041        self.port = port if port is not None else 0
4042        '''
4043
4044        '''
4045        self.port_override = port_override if port_override is not None else 0
4046        '''
4047
4048        '''
4049        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4050        '''
4051         ID of the secret store containing credentials for this resource, if any.
4052        '''
4053        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4054        '''
4055         Tags is a map of key, value pairs.
4056        '''
4057        self.tls_required = tls_required if tls_required is not None else False
4058        '''
4059
4060        '''
4061        self.username = username if username is not None else ''
4062        '''
4063
4064        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
4083    def to_dict(self):
4084        return {
4085            'bind_interface': self.bind_interface,
4086            'egress_filter': self.egress_filter,
4087            'healthy': self.healthy,
4088            'hostname': self.hostname,
4089            'id': self.id,
4090            'name': self.name,
4091            'password': self.password,
4092            'port': self.port,
4093            'port_override': self.port_override,
4094            'secret_store_id': self.secret_store_id,
4095            'tags': self.tags,
4096            'tls_required': self.tls_required,
4097            'username': self.username,
4098        }
@classmethod
def from_dict(cls, d)
4100    @classmethod
4101    def from_dict(cls, d):
4102        return cls(
4103            bind_interface=d.get('bind_interface'),
4104            egress_filter=d.get('egress_filter'),
4105            healthy=d.get('healthy'),
4106            hostname=d.get('hostname'),
4107            id=d.get('id'),
4108            name=d.get('name'),
4109            password=d.get('password'),
4110            port=d.get('port'),
4111            port_override=d.get('port_override'),
4112            secret_store_id=d.get('secret_store_id'),
4113            tags=d.get('tags'),
4114            tls_required=d.get('tls_required'),
4115            username=d.get('username'),
4116        )
class DB2LUW:
4119class DB2LUW:
4120    '''
4121
4122    '''
4123    __slots__ = [
4124        'bind_interface',
4125        'database',
4126        'egress_filter',
4127        'healthy',
4128        'hostname',
4129        'id',
4130        'name',
4131        'password',
4132        'port',
4133        'port_override',
4134        'secret_store_id',
4135        'tags',
4136        'username',
4137    ]
4138
4139    def __init__(
4140        self,
4141        bind_interface=None,
4142        database=None,
4143        egress_filter=None,
4144        healthy=None,
4145        hostname=None,
4146        id=None,
4147        name=None,
4148        password=None,
4149        port=None,
4150        port_override=None,
4151        secret_store_id=None,
4152        tags=None,
4153        username=None,
4154    ):
4155        self.bind_interface = bind_interface if bind_interface is not None else ''
4156        '''
4157         Bind interface
4158        '''
4159        self.database = database if database is not None else ''
4160        '''
4161
4162        '''
4163        self.egress_filter = egress_filter if egress_filter is not None else ''
4164        '''
4165         A filter applied to the routing logic to pin datasource to nodes.
4166        '''
4167        self.healthy = healthy if healthy is not None else False
4168        '''
4169         True if the datasource is reachable and the credentials are valid.
4170        '''
4171        self.hostname = hostname if hostname is not None else ''
4172        '''
4173
4174        '''
4175        self.id = id if id is not None else ''
4176        '''
4177         Unique identifier of the Resource.
4178        '''
4179        self.name = name if name is not None else ''
4180        '''
4181         Unique human-readable name of the Resource.
4182        '''
4183        self.password = password if password is not None else ''
4184        '''
4185
4186        '''
4187        self.port = port if port is not None else 0
4188        '''
4189
4190        '''
4191        self.port_override = port_override if port_override is not None else 0
4192        '''
4193
4194        '''
4195        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4196        '''
4197         ID of the secret store containing credentials for this resource, if any.
4198        '''
4199        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4200        '''
4201         Tags is a map of key, value pairs.
4202        '''
4203        self.username = username if username is not None else ''
4204        '''
4205
4206        '''
4207
4208    def __repr__(self):
4209        return '<sdm.DB2LUW ' + \
4210            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4211            'database: ' + repr(self.database) + ' ' +\
4212            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4213            'healthy: ' + repr(self.healthy) + ' ' +\
4214            'hostname: ' + repr(self.hostname) + ' ' +\
4215            'id: ' + repr(self.id) + ' ' +\
4216            'name: ' + repr(self.name) + ' ' +\
4217            'password: ' + repr(self.password) + ' ' +\
4218            'port: ' + repr(self.port) + ' ' +\
4219            'port_override: ' + repr(self.port_override) + ' ' +\
4220            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4221            'tags: ' + repr(self.tags) + ' ' +\
4222            'username: ' + repr(self.username) + ' ' +\
4223            '>'
4224
4225    def to_dict(self):
4226        return {
4227            'bind_interface': self.bind_interface,
4228            'database': self.database,
4229            'egress_filter': self.egress_filter,
4230            'healthy': self.healthy,
4231            'hostname': self.hostname,
4232            'id': self.id,
4233            'name': self.name,
4234            'password': self.password,
4235            'port': self.port,
4236            'port_override': self.port_override,
4237            'secret_store_id': self.secret_store_id,
4238            'tags': self.tags,
4239            'username': self.username,
4240        }
4241
4242    @classmethod
4243    def from_dict(cls, d):
4244        return cls(
4245            bind_interface=d.get('bind_interface'),
4246            database=d.get('database'),
4247            egress_filter=d.get('egress_filter'),
4248            healthy=d.get('healthy'),
4249            hostname=d.get('hostname'),
4250            id=d.get('id'),
4251            name=d.get('name'),
4252            password=d.get('password'),
4253            port=d.get('port'),
4254            port_override=d.get('port_override'),
4255            secret_store_id=d.get('secret_store_id'),
4256            tags=d.get('tags'),
4257            username=d.get('username'),
4258        )
DB2LUW( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4139    def __init__(
4140        self,
4141        bind_interface=None,
4142        database=None,
4143        egress_filter=None,
4144        healthy=None,
4145        hostname=None,
4146        id=None,
4147        name=None,
4148        password=None,
4149        port=None,
4150        port_override=None,
4151        secret_store_id=None,
4152        tags=None,
4153        username=None,
4154    ):
4155        self.bind_interface = bind_interface if bind_interface is not None else ''
4156        '''
4157         Bind interface
4158        '''
4159        self.database = database if database is not None else ''
4160        '''
4161
4162        '''
4163        self.egress_filter = egress_filter if egress_filter is not None else ''
4164        '''
4165         A filter applied to the routing logic to pin datasource to nodes.
4166        '''
4167        self.healthy = healthy if healthy is not None else False
4168        '''
4169         True if the datasource is reachable and the credentials are valid.
4170        '''
4171        self.hostname = hostname if hostname is not None else ''
4172        '''
4173
4174        '''
4175        self.id = id if id is not None else ''
4176        '''
4177         Unique identifier of the Resource.
4178        '''
4179        self.name = name if name is not None else ''
4180        '''
4181         Unique human-readable name of the Resource.
4182        '''
4183        self.password = password if password is not None else ''
4184        '''
4185
4186        '''
4187        self.port = port if port is not None else 0
4188        '''
4189
4190        '''
4191        self.port_override = port_override if port_override is not None else 0
4192        '''
4193
4194        '''
4195        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4196        '''
4197         ID of the secret store containing credentials for this resource, if any.
4198        '''
4199        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4200        '''
4201         Tags is a map of key, value pairs.
4202        '''
4203        self.username = username if username is not None else ''
4204        '''
4205
4206        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4225    def to_dict(self):
4226        return {
4227            'bind_interface': self.bind_interface,
4228            'database': self.database,
4229            'egress_filter': self.egress_filter,
4230            'healthy': self.healthy,
4231            'hostname': self.hostname,
4232            'id': self.id,
4233            'name': self.name,
4234            'password': self.password,
4235            'port': self.port,
4236            'port_override': self.port_override,
4237            'secret_store_id': self.secret_store_id,
4238            'tags': self.tags,
4239            'username': self.username,
4240        }
@classmethod
def from_dict(cls, d)
4242    @classmethod
4243    def from_dict(cls, d):
4244        return cls(
4245            bind_interface=d.get('bind_interface'),
4246            database=d.get('database'),
4247            egress_filter=d.get('egress_filter'),
4248            healthy=d.get('healthy'),
4249            hostname=d.get('hostname'),
4250            id=d.get('id'),
4251            name=d.get('name'),
4252            password=d.get('password'),
4253            port=d.get('port'),
4254            port_override=d.get('port_override'),
4255            secret_store_id=d.get('secret_store_id'),
4256            tags=d.get('tags'),
4257            username=d.get('username'),
4258        )
class DeleteResponseMetadata:
4261class DeleteResponseMetadata:
4262    '''
4263     DeleteResponseMetadata is reserved for future use.
4264    '''
4265    __slots__ = []
4266
4267    def __init__(self, ):
4268        pass
4269
4270    def __repr__(self):
4271        return '<sdm.DeleteResponseMetadata ' + \
4272            '>'
4273
4274    def to_dict(self):
4275        return {}
4276
4277    @classmethod
4278    def from_dict(cls, d):
4279        return cls()

DeleteResponseMetadata is reserved for future use.

DeleteResponseMetadata()
4267    def __init__(self, ):
4268        pass
def to_dict(self)
4274    def to_dict(self):
4275        return {}
@classmethod
def from_dict(cls, d)
4277    @classmethod
4278    def from_dict(cls, d):
4279        return cls()
class DocumentDBHost:
4282class DocumentDBHost:
4283    '''
4284
4285    '''
4286    __slots__ = [
4287        'auth_database',
4288        'bind_interface',
4289        'egress_filter',
4290        'healthy',
4291        'hostname',
4292        'id',
4293        'name',
4294        'password',
4295        'port',
4296        'port_override',
4297        'secret_store_id',
4298        'tags',
4299        'username',
4300    ]
4301
4302    def __init__(
4303        self,
4304        auth_database=None,
4305        bind_interface=None,
4306        egress_filter=None,
4307        healthy=None,
4308        hostname=None,
4309        id=None,
4310        name=None,
4311        password=None,
4312        port=None,
4313        port_override=None,
4314        secret_store_id=None,
4315        tags=None,
4316        username=None,
4317    ):
4318        self.auth_database = auth_database if auth_database is not None else ''
4319        '''
4320
4321        '''
4322        self.bind_interface = bind_interface if bind_interface is not None else ''
4323        '''
4324         Bind interface
4325        '''
4326        self.egress_filter = egress_filter if egress_filter is not None else ''
4327        '''
4328         A filter applied to the routing logic to pin datasource to nodes.
4329        '''
4330        self.healthy = healthy if healthy is not None else False
4331        '''
4332         True if the datasource is reachable and the credentials are valid.
4333        '''
4334        self.hostname = hostname if hostname is not None else ''
4335        '''
4336
4337        '''
4338        self.id = id if id is not None else ''
4339        '''
4340         Unique identifier of the Resource.
4341        '''
4342        self.name = name if name is not None else ''
4343        '''
4344         Unique human-readable name of the Resource.
4345        '''
4346        self.password = password if password is not None else ''
4347        '''
4348
4349        '''
4350        self.port = port if port is not None else 0
4351        '''
4352
4353        '''
4354        self.port_override = port_override if port_override is not None else 0
4355        '''
4356
4357        '''
4358        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4359        '''
4360         ID of the secret store containing credentials for this resource, if any.
4361        '''
4362        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4363        '''
4364         Tags is a map of key, value pairs.
4365        '''
4366        self.username = username if username is not None else ''
4367        '''
4368
4369        '''
4370
4371    def __repr__(self):
4372        return '<sdm.DocumentDBHost ' + \
4373            'auth_database: ' + repr(self.auth_database) + ' ' +\
4374            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4375            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4376            'healthy: ' + repr(self.healthy) + ' ' +\
4377            'hostname: ' + repr(self.hostname) + ' ' +\
4378            'id: ' + repr(self.id) + ' ' +\
4379            'name: ' + repr(self.name) + ' ' +\
4380            'password: ' + repr(self.password) + ' ' +\
4381            'port: ' + repr(self.port) + ' ' +\
4382            'port_override: ' + repr(self.port_override) + ' ' +\
4383            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4384            'tags: ' + repr(self.tags) + ' ' +\
4385            'username: ' + repr(self.username) + ' ' +\
4386            '>'
4387
4388    def to_dict(self):
4389        return {
4390            'auth_database': self.auth_database,
4391            'bind_interface': self.bind_interface,
4392            'egress_filter': self.egress_filter,
4393            'healthy': self.healthy,
4394            'hostname': self.hostname,
4395            'id': self.id,
4396            'name': self.name,
4397            'password': self.password,
4398            'port': self.port,
4399            'port_override': self.port_override,
4400            'secret_store_id': self.secret_store_id,
4401            'tags': self.tags,
4402            'username': self.username,
4403        }
4404
4405    @classmethod
4406    def from_dict(cls, d):
4407        return cls(
4408            auth_database=d.get('auth_database'),
4409            bind_interface=d.get('bind_interface'),
4410            egress_filter=d.get('egress_filter'),
4411            healthy=d.get('healthy'),
4412            hostname=d.get('hostname'),
4413            id=d.get('id'),
4414            name=d.get('name'),
4415            password=d.get('password'),
4416            port=d.get('port'),
4417            port_override=d.get('port_override'),
4418            secret_store_id=d.get('secret_store_id'),
4419            tags=d.get('tags'),
4420            username=d.get('username'),
4421        )
DocumentDBHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4302    def __init__(
4303        self,
4304        auth_database=None,
4305        bind_interface=None,
4306        egress_filter=None,
4307        healthy=None,
4308        hostname=None,
4309        id=None,
4310        name=None,
4311        password=None,
4312        port=None,
4313        port_override=None,
4314        secret_store_id=None,
4315        tags=None,
4316        username=None,
4317    ):
4318        self.auth_database = auth_database if auth_database is not None else ''
4319        '''
4320
4321        '''
4322        self.bind_interface = bind_interface if bind_interface is not None else ''
4323        '''
4324         Bind interface
4325        '''
4326        self.egress_filter = egress_filter if egress_filter is not None else ''
4327        '''
4328         A filter applied to the routing logic to pin datasource to nodes.
4329        '''
4330        self.healthy = healthy if healthy is not None else False
4331        '''
4332         True if the datasource is reachable and the credentials are valid.
4333        '''
4334        self.hostname = hostname if hostname is not None else ''
4335        '''
4336
4337        '''
4338        self.id = id if id is not None else ''
4339        '''
4340         Unique identifier of the Resource.
4341        '''
4342        self.name = name if name is not None else ''
4343        '''
4344         Unique human-readable name of the Resource.
4345        '''
4346        self.password = password if password is not None else ''
4347        '''
4348
4349        '''
4350        self.port = port if port is not None else 0
4351        '''
4352
4353        '''
4354        self.port_override = port_override if port_override is not None else 0
4355        '''
4356
4357        '''
4358        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4359        '''
4360         ID of the secret store containing credentials for this resource, if any.
4361        '''
4362        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4363        '''
4364         Tags is a map of key, value pairs.
4365        '''
4366        self.username = username if username is not None else ''
4367        '''
4368
4369        '''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4388    def to_dict(self):
4389        return {
4390            'auth_database': self.auth_database,
4391            'bind_interface': self.bind_interface,
4392            'egress_filter': self.egress_filter,
4393            'healthy': self.healthy,
4394            'hostname': self.hostname,
4395            'id': self.id,
4396            'name': self.name,
4397            'password': self.password,
4398            'port': self.port,
4399            'port_override': self.port_override,
4400            'secret_store_id': self.secret_store_id,
4401            'tags': self.tags,
4402            'username': self.username,
4403        }
@classmethod
def from_dict(cls, d)
4405    @classmethod
4406    def from_dict(cls, d):
4407        return cls(
4408            auth_database=d.get('auth_database'),
4409            bind_interface=d.get('bind_interface'),
4410            egress_filter=d.get('egress_filter'),
4411            healthy=d.get('healthy'),
4412            hostname=d.get('hostname'),
4413            id=d.get('id'),
4414            name=d.get('name'),
4415            password=d.get('password'),
4416            port=d.get('port'),
4417            port_override=d.get('port_override'),
4418            secret_store_id=d.get('secret_store_id'),
4419            tags=d.get('tags'),
4420            username=d.get('username'),
4421        )
class DocumentDBReplicaSet:
4424class DocumentDBReplicaSet:
4425    '''
4426
4427    '''
4428    __slots__ = [
4429        'auth_database',
4430        'bind_interface',
4431        'connect_to_replica',
4432        'egress_filter',
4433        'healthy',
4434        'hostname',
4435        'id',
4436        'name',
4437        'password',
4438        'port_override',
4439        'replica_set',
4440        'secret_store_id',
4441        'tags',
4442        'username',
4443    ]
4444
4445    def __init__(
4446        self,
4447        auth_database=None,
4448        bind_interface=None,
4449        connect_to_replica=None,
4450        egress_filter=None,
4451        healthy=None,
4452        hostname=None,
4453        id=None,
4454        name=None,
4455        password=None,
4456        port_override=None,
4457        replica_set=None,
4458        secret_store_id=None,
4459        tags=None,
4460        username=None,
4461    ):
4462        self.auth_database = auth_database if auth_database is not None else ''
4463        '''
4464
4465        '''
4466        self.bind_interface = bind_interface if bind_interface is not None else ''
4467        '''
4468         Bind interface
4469        '''
4470        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4471        '''
4472
4473        '''
4474        self.egress_filter = egress_filter if egress_filter is not None else ''
4475        '''
4476         A filter applied to the routing logic to pin datasource to nodes.
4477        '''
4478        self.healthy = healthy if healthy is not None else False
4479        '''
4480         True if the datasource is reachable and the credentials are valid.
4481        '''
4482        self.hostname = hostname if hostname is not None else ''
4483        '''
4484         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4485        '''
4486        self.id = id if id is not None else ''
4487        '''
4488         Unique identifier of the Resource.
4489        '''
4490        self.name = name if name is not None else ''
4491        '''
4492         Unique human-readable name of the Resource.
4493        '''
4494        self.password = password if password is not None else ''
4495        '''
4496
4497        '''
4498        self.port_override = port_override if port_override is not None else 0
4499        '''
4500
4501        '''
4502        self.replica_set = replica_set if replica_set is not None else ''
4503        '''
4504
4505        '''
4506        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4507        '''
4508         ID of the secret store containing credentials for this resource, if any.
4509        '''
4510        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4511        '''
4512         Tags is a map of key, value pairs.
4513        '''
4514        self.username = username if username is not None else ''
4515        '''
4516
4517        '''
4518
4519    def __repr__(self):
4520        return '<sdm.DocumentDBReplicaSet ' + \
4521            'auth_database: ' + repr(self.auth_database) + ' ' +\
4522            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4523            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
4524            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4525            'healthy: ' + repr(self.healthy) + ' ' +\
4526            'hostname: ' + repr(self.hostname) + ' ' +\
4527            'id: ' + repr(self.id) + ' ' +\
4528            'name: ' + repr(self.name) + ' ' +\
4529            'password: ' + repr(self.password) + ' ' +\
4530            'port_override: ' + repr(self.port_override) + ' ' +\
4531            'replica_set: ' + repr(self.replica_set) + ' ' +\
4532            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4533            'tags: ' + repr(self.tags) + ' ' +\
4534            'username: ' + repr(self.username) + ' ' +\
4535            '>'
4536
4537    def to_dict(self):
4538        return {
4539            'auth_database': self.auth_database,
4540            'bind_interface': self.bind_interface,
4541            'connect_to_replica': self.connect_to_replica,
4542            'egress_filter': self.egress_filter,
4543            'healthy': self.healthy,
4544            'hostname': self.hostname,
4545            'id': self.id,
4546            'name': self.name,
4547            'password': self.password,
4548            'port_override': self.port_override,
4549            'replica_set': self.replica_set,
4550            'secret_store_id': self.secret_store_id,
4551            'tags': self.tags,
4552            'username': self.username,
4553        }
4554
4555    @classmethod
4556    def from_dict(cls, d):
4557        return cls(
4558            auth_database=d.get('auth_database'),
4559            bind_interface=d.get('bind_interface'),
4560            connect_to_replica=d.get('connect_to_replica'),
4561            egress_filter=d.get('egress_filter'),
4562            healthy=d.get('healthy'),
4563            hostname=d.get('hostname'),
4564            id=d.get('id'),
4565            name=d.get('name'),
4566            password=d.get('password'),
4567            port_override=d.get('port_override'),
4568            replica_set=d.get('replica_set'),
4569            secret_store_id=d.get('secret_store_id'),
4570            tags=d.get('tags'),
4571            username=d.get('username'),
4572        )
DocumentDBReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, username=None)
4445    def __init__(
4446        self,
4447        auth_database=None,
4448        bind_interface=None,
4449        connect_to_replica=None,
4450        egress_filter=None,
4451        healthy=None,
4452        hostname=None,
4453        id=None,
4454        name=None,
4455        password=None,
4456        port_override=None,
4457        replica_set=None,
4458        secret_store_id=None,
4459        tags=None,
4460        username=None,
4461    ):
4462        self.auth_database = auth_database if auth_database is not None else ''
4463        '''
4464
4465        '''
4466        self.bind_interface = bind_interface if bind_interface is not None else ''
4467        '''
4468         Bind interface
4469        '''
4470        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4471        '''
4472
4473        '''
4474        self.egress_filter = egress_filter if egress_filter is not None else ''
4475        '''
4476         A filter applied to the routing logic to pin datasource to nodes.
4477        '''
4478        self.healthy = healthy if healthy is not None else False
4479        '''
4480         True if the datasource is reachable and the credentials are valid.
4481        '''
4482        self.hostname = hostname if hostname is not None else ''
4483        '''
4484         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4485        '''
4486        self.id = id if id is not None else ''
4487        '''
4488         Unique identifier of the Resource.
4489        '''
4490        self.name = name if name is not None else ''
4491        '''
4492         Unique human-readable name of the Resource.
4493        '''
4494        self.password = password if password is not None else ''
4495        '''
4496
4497        '''
4498        self.port_override = port_override if port_override is not None else 0
4499        '''
4500
4501        '''
4502        self.replica_set = replica_set if replica_set is not None else ''
4503        '''
4504
4505        '''
4506        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4507        '''
4508         ID of the secret store containing credentials for this resource, if any.
4509        '''
4510        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4511        '''
4512         Tags is a map of key, value pairs.
4513        '''
4514        self.username = username if username is not None else ''
4515        '''
4516
4517        '''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname

Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4537    def to_dict(self):
4538        return {
4539            'auth_database': self.auth_database,
4540            'bind_interface': self.bind_interface,
4541            'connect_to_replica': self.connect_to_replica,
4542            'egress_filter': self.egress_filter,
4543            'healthy': self.healthy,
4544            'hostname': self.hostname,
4545            'id': self.id,
4546            'name': self.name,
4547            'password': self.password,
4548            'port_override': self.port_override,
4549            'replica_set': self.replica_set,
4550            'secret_store_id': self.secret_store_id,
4551            'tags': self.tags,
4552            'username': self.username,
4553        }
@classmethod
def from_dict(cls, d)
4555    @classmethod
4556    def from_dict(cls, d):
4557        return cls(
4558            auth_database=d.get('auth_database'),
4559            bind_interface=d.get('bind_interface'),
4560            connect_to_replica=d.get('connect_to_replica'),
4561            egress_filter=d.get('egress_filter'),
4562            healthy=d.get('healthy'),
4563            hostname=d.get('hostname'),
4564            id=d.get('id'),
4565            name=d.get('name'),
4566            password=d.get('password'),
4567            port_override=d.get('port_override'),
4568            replica_set=d.get('replica_set'),
4569            secret_store_id=d.get('secret_store_id'),
4570            tags=d.get('tags'),
4571            username=d.get('username'),
4572        )
class Druid:
4575class Druid:
4576    '''
4577
4578    '''
4579    __slots__ = [
4580        'bind_interface',
4581        'egress_filter',
4582        'healthy',
4583        'hostname',
4584        'id',
4585        'name',
4586        'password',
4587        'port',
4588        'port_override',
4589        'secret_store_id',
4590        'tags',
4591        'username',
4592    ]
4593
4594    def __init__(
4595        self,
4596        bind_interface=None,
4597        egress_filter=None,
4598        healthy=None,
4599        hostname=None,
4600        id=None,
4601        name=None,
4602        password=None,
4603        port=None,
4604        port_override=None,
4605        secret_store_id=None,
4606        tags=None,
4607        username=None,
4608    ):
4609        self.bind_interface = bind_interface if bind_interface is not None else ''
4610        '''
4611         Bind interface
4612        '''
4613        self.egress_filter = egress_filter if egress_filter is not None else ''
4614        '''
4615         A filter applied to the routing logic to pin datasource to nodes.
4616        '''
4617        self.healthy = healthy if healthy is not None else False
4618        '''
4619         True if the datasource is reachable and the credentials are valid.
4620        '''
4621        self.hostname = hostname if hostname is not None else ''
4622        '''
4623
4624        '''
4625        self.id = id if id is not None else ''
4626        '''
4627         Unique identifier of the Resource.
4628        '''
4629        self.name = name if name is not None else ''
4630        '''
4631         Unique human-readable name of the Resource.
4632        '''
4633        self.password = password if password is not None else ''
4634        '''
4635
4636        '''
4637        self.port = port if port is not None else 0
4638        '''
4639
4640        '''
4641        self.port_override = port_override if port_override is not None else 0
4642        '''
4643
4644        '''
4645        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4646        '''
4647         ID of the secret store containing credentials for this resource, if any.
4648        '''
4649        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4650        '''
4651         Tags is a map of key, value pairs.
4652        '''
4653        self.username = username if username is not None else ''
4654        '''
4655
4656        '''
4657
4658    def __repr__(self):
4659        return '<sdm.Druid ' + \
4660            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4661            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4662            'healthy: ' + repr(self.healthy) + ' ' +\
4663            'hostname: ' + repr(self.hostname) + ' ' +\
4664            'id: ' + repr(self.id) + ' ' +\
4665            'name: ' + repr(self.name) + ' ' +\
4666            'password: ' + repr(self.password) + ' ' +\
4667            'port: ' + repr(self.port) + ' ' +\
4668            'port_override: ' + repr(self.port_override) + ' ' +\
4669            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4670            'tags: ' + repr(self.tags) + ' ' +\
4671            'username: ' + repr(self.username) + ' ' +\
4672            '>'
4673
4674    def to_dict(self):
4675        return {
4676            'bind_interface': self.bind_interface,
4677            'egress_filter': self.egress_filter,
4678            'healthy': self.healthy,
4679            'hostname': self.hostname,
4680            'id': self.id,
4681            'name': self.name,
4682            'password': self.password,
4683            'port': self.port,
4684            'port_override': self.port_override,
4685            'secret_store_id': self.secret_store_id,
4686            'tags': self.tags,
4687            'username': self.username,
4688        }
4689
4690    @classmethod
4691    def from_dict(cls, d):
4692        return cls(
4693            bind_interface=d.get('bind_interface'),
4694            egress_filter=d.get('egress_filter'),
4695            healthy=d.get('healthy'),
4696            hostname=d.get('hostname'),
4697            id=d.get('id'),
4698            name=d.get('name'),
4699            password=d.get('password'),
4700            port=d.get('port'),
4701            port_override=d.get('port_override'),
4702            secret_store_id=d.get('secret_store_id'),
4703            tags=d.get('tags'),
4704            username=d.get('username'),
4705        )
Druid( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4594    def __init__(
4595        self,
4596        bind_interface=None,
4597        egress_filter=None,
4598        healthy=None,
4599        hostname=None,
4600        id=None,
4601        name=None,
4602        password=None,
4603        port=None,
4604        port_override=None,
4605        secret_store_id=None,
4606        tags=None,
4607        username=None,
4608    ):
4609        self.bind_interface = bind_interface if bind_interface is not None else ''
4610        '''
4611         Bind interface
4612        '''
4613        self.egress_filter = egress_filter if egress_filter is not None else ''
4614        '''
4615         A filter applied to the routing logic to pin datasource to nodes.
4616        '''
4617        self.healthy = healthy if healthy is not None else False
4618        '''
4619         True if the datasource is reachable and the credentials are valid.
4620        '''
4621        self.hostname = hostname if hostname is not None else ''
4622        '''
4623
4624        '''
4625        self.id = id if id is not None else ''
4626        '''
4627         Unique identifier of the Resource.
4628        '''
4629        self.name = name if name is not None else ''
4630        '''
4631         Unique human-readable name of the Resource.
4632        '''
4633        self.password = password if password is not None else ''
4634        '''
4635
4636        '''
4637        self.port = port if port is not None else 0
4638        '''
4639
4640        '''
4641        self.port_override = port_override if port_override is not None else 0
4642        '''
4643
4644        '''
4645        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4646        '''
4647         ID of the secret store containing credentials for this resource, if any.
4648        '''
4649        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4650        '''
4651         Tags is a map of key, value pairs.
4652        '''
4653        self.username = username if username is not None else ''
4654        '''
4655
4656        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4674    def to_dict(self):
4675        return {
4676            'bind_interface': self.bind_interface,
4677            'egress_filter': self.egress_filter,
4678            'healthy': self.healthy,
4679            'hostname': self.hostname,
4680            'id': self.id,
4681            'name': self.name,
4682            'password': self.password,
4683            'port': self.port,
4684            'port_override': self.port_override,
4685            'secret_store_id': self.secret_store_id,
4686            'tags': self.tags,
4687            'username': self.username,
4688        }
@classmethod
def from_dict(cls, d)
4690    @classmethod
4691    def from_dict(cls, d):
4692        return cls(
4693            bind_interface=d.get('bind_interface'),
4694            egress_filter=d.get('egress_filter'),
4695            healthy=d.get('healthy'),
4696            hostname=d.get('hostname'),
4697            id=d.get('id'),
4698            name=d.get('name'),
4699            password=d.get('password'),
4700            port=d.get('port'),
4701            port_override=d.get('port_override'),
4702            secret_store_id=d.get('secret_store_id'),
4703            tags=d.get('tags'),
4704            username=d.get('username'),
4705        )
class DynamoDB:
4708class DynamoDB:
4709    '''
4710
4711    '''
4712    __slots__ = [
4713        'access_key',
4714        'bind_interface',
4715        'egress_filter',
4716        'endpoint',
4717        'healthy',
4718        'id',
4719        'name',
4720        'port_override',
4721        'region',
4722        'role_arn',
4723        'role_external_id',
4724        'secret_access_key',
4725        'secret_store_id',
4726        'tags',
4727    ]
4728
4729    def __init__(
4730        self,
4731        access_key=None,
4732        bind_interface=None,
4733        egress_filter=None,
4734        endpoint=None,
4735        healthy=None,
4736        id=None,
4737        name=None,
4738        port_override=None,
4739        region=None,
4740        role_arn=None,
4741        role_external_id=None,
4742        secret_access_key=None,
4743        secret_store_id=None,
4744        tags=None,
4745    ):
4746        self.access_key = access_key if access_key is not None else ''
4747        '''
4748
4749        '''
4750        self.bind_interface = bind_interface if bind_interface is not None else ''
4751        '''
4752         Bind interface
4753        '''
4754        self.egress_filter = egress_filter if egress_filter is not None else ''
4755        '''
4756         A filter applied to the routing logic to pin datasource to nodes.
4757        '''
4758        self.endpoint = endpoint if endpoint is not None else ''
4759        '''
4760
4761        '''
4762        self.healthy = healthy if healthy is not None else False
4763        '''
4764         True if the datasource is reachable and the credentials are valid.
4765        '''
4766        self.id = id if id is not None else ''
4767        '''
4768         Unique identifier of the Resource.
4769        '''
4770        self.name = name if name is not None else ''
4771        '''
4772         Unique human-readable name of the Resource.
4773        '''
4774        self.port_override = port_override if port_override is not None else 0
4775        '''
4776
4777        '''
4778        self.region = region if region is not None else ''
4779        '''
4780
4781        '''
4782        self.role_arn = role_arn if role_arn is not None else ''
4783        '''
4784
4785        '''
4786        self.role_external_id = role_external_id if role_external_id is not None else ''
4787        '''
4788
4789        '''
4790        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4791        '''
4792
4793        '''
4794        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4795        '''
4796         ID of the secret store containing credentials for this resource, if any.
4797        '''
4798        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4799        '''
4800         Tags is a map of key, value pairs.
4801        '''
4802
4803    def __repr__(self):
4804        return '<sdm.DynamoDB ' + \
4805            'access_key: ' + repr(self.access_key) + ' ' +\
4806            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4807            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4808            'endpoint: ' + repr(self.endpoint) + ' ' +\
4809            'healthy: ' + repr(self.healthy) + ' ' +\
4810            'id: ' + repr(self.id) + ' ' +\
4811            'name: ' + repr(self.name) + ' ' +\
4812            'port_override: ' + repr(self.port_override) + ' ' +\
4813            'region: ' + repr(self.region) + ' ' +\
4814            'role_arn: ' + repr(self.role_arn) + ' ' +\
4815            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
4816            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
4817            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4818            'tags: ' + repr(self.tags) + ' ' +\
4819            '>'
4820
4821    def to_dict(self):
4822        return {
4823            'access_key': self.access_key,
4824            'bind_interface': self.bind_interface,
4825            'egress_filter': self.egress_filter,
4826            'endpoint': self.endpoint,
4827            'healthy': self.healthy,
4828            'id': self.id,
4829            'name': self.name,
4830            'port_override': self.port_override,
4831            'region': self.region,
4832            'role_arn': self.role_arn,
4833            'role_external_id': self.role_external_id,
4834            'secret_access_key': self.secret_access_key,
4835            'secret_store_id': self.secret_store_id,
4836            'tags': self.tags,
4837        }
4838
4839    @classmethod
4840    def from_dict(cls, d):
4841        return cls(
4842            access_key=d.get('access_key'),
4843            bind_interface=d.get('bind_interface'),
4844            egress_filter=d.get('egress_filter'),
4845            endpoint=d.get('endpoint'),
4846            healthy=d.get('healthy'),
4847            id=d.get('id'),
4848            name=d.get('name'),
4849            port_override=d.get('port_override'),
4850            region=d.get('region'),
4851            role_arn=d.get('role_arn'),
4852            role_external_id=d.get('role_external_id'),
4853            secret_access_key=d.get('secret_access_key'),
4854            secret_store_id=d.get('secret_store_id'),
4855            tags=d.get('tags'),
4856        )
DynamoDB( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
4729    def __init__(
4730        self,
4731        access_key=None,
4732        bind_interface=None,
4733        egress_filter=None,
4734        endpoint=None,
4735        healthy=None,
4736        id=None,
4737        name=None,
4738        port_override=None,
4739        region=None,
4740        role_arn=None,
4741        role_external_id=None,
4742        secret_access_key=None,
4743        secret_store_id=None,
4744        tags=None,
4745    ):
4746        self.access_key = access_key if access_key is not None else ''
4747        '''
4748
4749        '''
4750        self.bind_interface = bind_interface if bind_interface is not None else ''
4751        '''
4752         Bind interface
4753        '''
4754        self.egress_filter = egress_filter if egress_filter is not None else ''
4755        '''
4756         A filter applied to the routing logic to pin datasource to nodes.
4757        '''
4758        self.endpoint = endpoint if endpoint is not None else ''
4759        '''
4760
4761        '''
4762        self.healthy = healthy if healthy is not None else False
4763        '''
4764         True if the datasource is reachable and the credentials are valid.
4765        '''
4766        self.id = id if id is not None else ''
4767        '''
4768         Unique identifier of the Resource.
4769        '''
4770        self.name = name if name is not None else ''
4771        '''
4772         Unique human-readable name of the Resource.
4773        '''
4774        self.port_override = port_override if port_override is not None else 0
4775        '''
4776
4777        '''
4778        self.region = region if region is not None else ''
4779        '''
4780
4781        '''
4782        self.role_arn = role_arn if role_arn is not None else ''
4783        '''
4784
4785        '''
4786        self.role_external_id = role_external_id if role_external_id is not None else ''
4787        '''
4788
4789        '''
4790        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4791        '''
4792
4793        '''
4794        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4795        '''
4796         ID of the secret store containing credentials for this resource, if any.
4797        '''
4798        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4799        '''
4800         Tags is a map of key, value pairs.
4801        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4821    def to_dict(self):
4822        return {
4823            'access_key': self.access_key,
4824            'bind_interface': self.bind_interface,
4825            'egress_filter': self.egress_filter,
4826            'endpoint': self.endpoint,
4827            'healthy': self.healthy,
4828            'id': self.id,
4829            'name': self.name,
4830            'port_override': self.port_override,
4831            'region': self.region,
4832            'role_arn': self.role_arn,
4833            'role_external_id': self.role_external_id,
4834            'secret_access_key': self.secret_access_key,
4835            'secret_store_id': self.secret_store_id,
4836            'tags': self.tags,
4837        }
@classmethod
def from_dict(cls, d)
4839    @classmethod
4840    def from_dict(cls, d):
4841        return cls(
4842            access_key=d.get('access_key'),
4843            bind_interface=d.get('bind_interface'),
4844            egress_filter=d.get('egress_filter'),
4845            endpoint=d.get('endpoint'),
4846            healthy=d.get('healthy'),
4847            id=d.get('id'),
4848            name=d.get('name'),
4849            port_override=d.get('port_override'),
4850            region=d.get('region'),
4851            role_arn=d.get('role_arn'),
4852            role_external_id=d.get('role_external_id'),
4853            secret_access_key=d.get('secret_access_key'),
4854            secret_store_id=d.get('secret_store_id'),
4855            tags=d.get('tags'),
4856        )
class Elastic:
4859class Elastic:
4860    '''
4861
4862    '''
4863    __slots__ = [
4864        'bind_interface',
4865        'egress_filter',
4866        'healthy',
4867        'hostname',
4868        'id',
4869        'name',
4870        'password',
4871        'port',
4872        'port_override',
4873        'secret_store_id',
4874        'tags',
4875        'tls_required',
4876        'username',
4877    ]
4878
4879    def __init__(
4880        self,
4881        bind_interface=None,
4882        egress_filter=None,
4883        healthy=None,
4884        hostname=None,
4885        id=None,
4886        name=None,
4887        password=None,
4888        port=None,
4889        port_override=None,
4890        secret_store_id=None,
4891        tags=None,
4892        tls_required=None,
4893        username=None,
4894    ):
4895        self.bind_interface = bind_interface if bind_interface is not None else ''
4896        '''
4897         Bind interface
4898        '''
4899        self.egress_filter = egress_filter if egress_filter is not None else ''
4900        '''
4901         A filter applied to the routing logic to pin datasource to nodes.
4902        '''
4903        self.healthy = healthy if healthy is not None else False
4904        '''
4905         True if the datasource is reachable and the credentials are valid.
4906        '''
4907        self.hostname = hostname if hostname is not None else ''
4908        '''
4909
4910        '''
4911        self.id = id if id is not None else ''
4912        '''
4913         Unique identifier of the Resource.
4914        '''
4915        self.name = name if name is not None else ''
4916        '''
4917         Unique human-readable name of the Resource.
4918        '''
4919        self.password = password if password is not None else ''
4920        '''
4921
4922        '''
4923        self.port = port if port is not None else 0
4924        '''
4925
4926        '''
4927        self.port_override = port_override if port_override is not None else 0
4928        '''
4929
4930        '''
4931        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4932        '''
4933         ID of the secret store containing credentials for this resource, if any.
4934        '''
4935        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4936        '''
4937         Tags is a map of key, value pairs.
4938        '''
4939        self.tls_required = tls_required if tls_required is not None else False
4940        '''
4941
4942        '''
4943        self.username = username if username is not None else ''
4944        '''
4945
4946        '''
4947
4948    def __repr__(self):
4949        return '<sdm.Elastic ' + \
4950            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4951            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4952            'healthy: ' + repr(self.healthy) + ' ' +\
4953            'hostname: ' + repr(self.hostname) + ' ' +\
4954            'id: ' + repr(self.id) + ' ' +\
4955            'name: ' + repr(self.name) + ' ' +\
4956            'password: ' + repr(self.password) + ' ' +\
4957            'port: ' + repr(self.port) + ' ' +\
4958            'port_override: ' + repr(self.port_override) + ' ' +\
4959            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4960            'tags: ' + repr(self.tags) + ' ' +\
4961            'tls_required: ' + repr(self.tls_required) + ' ' +\
4962            'username: ' + repr(self.username) + ' ' +\
4963            '>'
4964
4965    def to_dict(self):
4966        return {
4967            'bind_interface': self.bind_interface,
4968            'egress_filter': self.egress_filter,
4969            'healthy': self.healthy,
4970            'hostname': self.hostname,
4971            'id': self.id,
4972            'name': self.name,
4973            'password': self.password,
4974            'port': self.port,
4975            'port_override': self.port_override,
4976            'secret_store_id': self.secret_store_id,
4977            'tags': self.tags,
4978            'tls_required': self.tls_required,
4979            'username': self.username,
4980        }
4981
4982    @classmethod
4983    def from_dict(cls, d):
4984        return cls(
4985            bind_interface=d.get('bind_interface'),
4986            egress_filter=d.get('egress_filter'),
4987            healthy=d.get('healthy'),
4988            hostname=d.get('hostname'),
4989            id=d.get('id'),
4990            name=d.get('name'),
4991            password=d.get('password'),
4992            port=d.get('port'),
4993            port_override=d.get('port_override'),
4994            secret_store_id=d.get('secret_store_id'),
4995            tags=d.get('tags'),
4996            tls_required=d.get('tls_required'),
4997            username=d.get('username'),
4998        )
Elastic( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
4879    def __init__(
4880        self,
4881        bind_interface=None,
4882        egress_filter=None,
4883        healthy=None,
4884        hostname=None,
4885        id=None,
4886        name=None,
4887        password=None,
4888        port=None,
4889        port_override=None,
4890        secret_store_id=None,
4891        tags=None,
4892        tls_required=None,
4893        username=None,
4894    ):
4895        self.bind_interface = bind_interface if bind_interface is not None else ''
4896        '''
4897         Bind interface
4898        '''
4899        self.egress_filter = egress_filter if egress_filter is not None else ''
4900        '''
4901         A filter applied to the routing logic to pin datasource to nodes.
4902        '''
4903        self.healthy = healthy if healthy is not None else False
4904        '''
4905         True if the datasource is reachable and the credentials are valid.
4906        '''
4907        self.hostname = hostname if hostname is not None else ''
4908        '''
4909
4910        '''
4911        self.id = id if id is not None else ''
4912        '''
4913         Unique identifier of the Resource.
4914        '''
4915        self.name = name if name is not None else ''
4916        '''
4917         Unique human-readable name of the Resource.
4918        '''
4919        self.password = password if password is not None else ''
4920        '''
4921
4922        '''
4923        self.port = port if port is not None else 0
4924        '''
4925
4926        '''
4927        self.port_override = port_override if port_override is not None else 0
4928        '''
4929
4930        '''
4931        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4932        '''
4933         ID of the secret store containing credentials for this resource, if any.
4934        '''
4935        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4936        '''
4937         Tags is a map of key, value pairs.
4938        '''
4939        self.tls_required = tls_required if tls_required is not None else False
4940        '''
4941
4942        '''
4943        self.username = username if username is not None else ''
4944        '''
4945
4946        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
4965    def to_dict(self):
4966        return {
4967            'bind_interface': self.bind_interface,
4968            'egress_filter': self.egress_filter,
4969            'healthy': self.healthy,
4970            'hostname': self.hostname,
4971            'id': self.id,
4972            'name': self.name,
4973            'password': self.password,
4974            'port': self.port,
4975            'port_override': self.port_override,
4976            'secret_store_id': self.secret_store_id,
4977            'tags': self.tags,
4978            'tls_required': self.tls_required,
4979            'username': self.username,
4980        }
@classmethod
def from_dict(cls, d)
4982    @classmethod
4983    def from_dict(cls, d):
4984        return cls(
4985            bind_interface=d.get('bind_interface'),
4986            egress_filter=d.get('egress_filter'),
4987            healthy=d.get('healthy'),
4988            hostname=d.get('hostname'),
4989            id=d.get('id'),
4990            name=d.get('name'),
4991            password=d.get('password'),
4992            port=d.get('port'),
4993            port_override=d.get('port_override'),
4994            secret_store_id=d.get('secret_store_id'),
4995            tags=d.get('tags'),
4996            tls_required=d.get('tls_required'),
4997            username=d.get('username'),
4998        )
class ElasticacheRedis:
5001class ElasticacheRedis:
5002    '''
5003
5004    '''
5005    __slots__ = [
5006        'bind_interface',
5007        'egress_filter',
5008        'healthy',
5009        'hostname',
5010        'id',
5011        'name',
5012        'password',
5013        'port',
5014        'port_override',
5015        'secret_store_id',
5016        'tags',
5017        'tls_required',
5018    ]
5019
5020    def __init__(
5021        self,
5022        bind_interface=None,
5023        egress_filter=None,
5024        healthy=None,
5025        hostname=None,
5026        id=None,
5027        name=None,
5028        password=None,
5029        port=None,
5030        port_override=None,
5031        secret_store_id=None,
5032        tags=None,
5033        tls_required=None,
5034    ):
5035        self.bind_interface = bind_interface if bind_interface is not None else ''
5036        '''
5037         Bind interface
5038        '''
5039        self.egress_filter = egress_filter if egress_filter is not None else ''
5040        '''
5041         A filter applied to the routing logic to pin datasource to nodes.
5042        '''
5043        self.healthy = healthy if healthy is not None else False
5044        '''
5045         True if the datasource is reachable and the credentials are valid.
5046        '''
5047        self.hostname = hostname if hostname is not None else ''
5048        '''
5049
5050        '''
5051        self.id = id if id is not None else ''
5052        '''
5053         Unique identifier of the Resource.
5054        '''
5055        self.name = name if name is not None else ''
5056        '''
5057         Unique human-readable name of the Resource.
5058        '''
5059        self.password = password if password is not None else ''
5060        '''
5061
5062        '''
5063        self.port = port if port is not None else 0
5064        '''
5065
5066        '''
5067        self.port_override = port_override if port_override is not None else 0
5068        '''
5069
5070        '''
5071        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5072        '''
5073         ID of the secret store containing credentials for this resource, if any.
5074        '''
5075        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5076        '''
5077         Tags is a map of key, value pairs.
5078        '''
5079        self.tls_required = tls_required if tls_required is not None else False
5080        '''
5081
5082        '''
5083
5084    def __repr__(self):
5085        return '<sdm.ElasticacheRedis ' + \
5086            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5087            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5088            'healthy: ' + repr(self.healthy) + ' ' +\
5089            'hostname: ' + repr(self.hostname) + ' ' +\
5090            'id: ' + repr(self.id) + ' ' +\
5091            'name: ' + repr(self.name) + ' ' +\
5092            'password: ' + repr(self.password) + ' ' +\
5093            'port: ' + repr(self.port) + ' ' +\
5094            'port_override: ' + repr(self.port_override) + ' ' +\
5095            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5096            'tags: ' + repr(self.tags) + ' ' +\
5097            'tls_required: ' + repr(self.tls_required) + ' ' +\
5098            '>'
5099
5100    def to_dict(self):
5101        return {
5102            'bind_interface': self.bind_interface,
5103            'egress_filter': self.egress_filter,
5104            'healthy': self.healthy,
5105            'hostname': self.hostname,
5106            'id': self.id,
5107            'name': self.name,
5108            'password': self.password,
5109            'port': self.port,
5110            'port_override': self.port_override,
5111            'secret_store_id': self.secret_store_id,
5112            'tags': self.tags,
5113            'tls_required': self.tls_required,
5114        }
5115
5116    @classmethod
5117    def from_dict(cls, d):
5118        return cls(
5119            bind_interface=d.get('bind_interface'),
5120            egress_filter=d.get('egress_filter'),
5121            healthy=d.get('healthy'),
5122            hostname=d.get('hostname'),
5123            id=d.get('id'),
5124            name=d.get('name'),
5125            password=d.get('password'),
5126            port=d.get('port'),
5127            port_override=d.get('port_override'),
5128            secret_store_id=d.get('secret_store_id'),
5129            tags=d.get('tags'),
5130            tls_required=d.get('tls_required'),
5131        )
ElasticacheRedis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None)
5020    def __init__(
5021        self,
5022        bind_interface=None,
5023        egress_filter=None,
5024        healthy=None,
5025        hostname=None,
5026        id=None,
5027        name=None,
5028        password=None,
5029        port=None,
5030        port_override=None,
5031        secret_store_id=None,
5032        tags=None,
5033        tls_required=None,
5034    ):
5035        self.bind_interface = bind_interface if bind_interface is not None else ''
5036        '''
5037         Bind interface
5038        '''
5039        self.egress_filter = egress_filter if egress_filter is not None else ''
5040        '''
5041         A filter applied to the routing logic to pin datasource to nodes.
5042        '''
5043        self.healthy = healthy if healthy is not None else False
5044        '''
5045         True if the datasource is reachable and the credentials are valid.
5046        '''
5047        self.hostname = hostname if hostname is not None else ''
5048        '''
5049
5050        '''
5051        self.id = id if id is not None else ''
5052        '''
5053         Unique identifier of the Resource.
5054        '''
5055        self.name = name if name is not None else ''
5056        '''
5057         Unique human-readable name of the Resource.
5058        '''
5059        self.password = password if password is not None else ''
5060        '''
5061
5062        '''
5063        self.port = port if port is not None else 0
5064        '''
5065
5066        '''
5067        self.port_override = port_override if port_override is not None else 0
5068        '''
5069
5070        '''
5071        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5072        '''
5073         ID of the secret store containing credentials for this resource, if any.
5074        '''
5075        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5076        '''
5077         Tags is a map of key, value pairs.
5078        '''
5079        self.tls_required = tls_required if tls_required is not None else False
5080        '''
5081
5082        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
def to_dict(self)
5100    def to_dict(self):
5101        return {
5102            'bind_interface': self.bind_interface,
5103            'egress_filter': self.egress_filter,
5104            'healthy': self.healthy,
5105            'hostname': self.hostname,
5106            'id': self.id,
5107            'name': self.name,
5108            'password': self.password,
5109            'port': self.port,
5110            'port_override': self.port_override,
5111            'secret_store_id': self.secret_store_id,
5112            'tags': self.tags,
5113            'tls_required': self.tls_required,
5114        }
@classmethod
def from_dict(cls, d)
5116    @classmethod
5117    def from_dict(cls, d):
5118        return cls(
5119            bind_interface=d.get('bind_interface'),
5120            egress_filter=d.get('egress_filter'),
5121            healthy=d.get('healthy'),
5122            hostname=d.get('hostname'),
5123            id=d.get('id'),
5124            name=d.get('name'),
5125            password=d.get('password'),
5126            port=d.get('port'),
5127            port_override=d.get('port_override'),
5128            secret_store_id=d.get('secret_store_id'),
5129            tags=d.get('tags'),
5130            tls_required=d.get('tls_required'),
5131        )
class GCP:
5134class GCP:
5135    '''
5136
5137    '''
5138    __slots__ = [
5139        'bind_interface',
5140        'egress_filter',
5141        'healthy',
5142        'id',
5143        'keyfile',
5144        'name',
5145        'scopes',
5146        'secret_store_id',
5147        'tags',
5148    ]
5149
5150    def __init__(
5151        self,
5152        bind_interface=None,
5153        egress_filter=None,
5154        healthy=None,
5155        id=None,
5156        keyfile=None,
5157        name=None,
5158        scopes=None,
5159        secret_store_id=None,
5160        tags=None,
5161    ):
5162        self.bind_interface = bind_interface if bind_interface is not None else ''
5163        '''
5164         Bind interface
5165        '''
5166        self.egress_filter = egress_filter if egress_filter is not None else ''
5167        '''
5168         A filter applied to the routing logic to pin datasource to nodes.
5169        '''
5170        self.healthy = healthy if healthy is not None else False
5171        '''
5172         True if the datasource is reachable and the credentials are valid.
5173        '''
5174        self.id = id if id is not None else ''
5175        '''
5176         Unique identifier of the Resource.
5177        '''
5178        self.keyfile = keyfile if keyfile is not None else ''
5179        '''
5180
5181        '''
5182        self.name = name if name is not None else ''
5183        '''
5184         Unique human-readable name of the Resource.
5185        '''
5186        self.scopes = scopes if scopes is not None else ''
5187        '''
5188
5189        '''
5190        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5191        '''
5192         ID of the secret store containing credentials for this resource, if any.
5193        '''
5194        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5195        '''
5196         Tags is a map of key, value pairs.
5197        '''
5198
5199    def __repr__(self):
5200        return '<sdm.GCP ' + \
5201            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5202            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5203            'healthy: ' + repr(self.healthy) + ' ' +\
5204            'id: ' + repr(self.id) + ' ' +\
5205            'keyfile: ' + repr(self.keyfile) + ' ' +\
5206            'name: ' + repr(self.name) + ' ' +\
5207            'scopes: ' + repr(self.scopes) + ' ' +\
5208            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5209            'tags: ' + repr(self.tags) + ' ' +\
5210            '>'
5211
5212    def to_dict(self):
5213        return {
5214            'bind_interface': self.bind_interface,
5215            'egress_filter': self.egress_filter,
5216            'healthy': self.healthy,
5217            'id': self.id,
5218            'keyfile': self.keyfile,
5219            'name': self.name,
5220            'scopes': self.scopes,
5221            'secret_store_id': self.secret_store_id,
5222            'tags': self.tags,
5223        }
5224
5225    @classmethod
5226    def from_dict(cls, d):
5227        return cls(
5228            bind_interface=d.get('bind_interface'),
5229            egress_filter=d.get('egress_filter'),
5230            healthy=d.get('healthy'),
5231            id=d.get('id'),
5232            keyfile=d.get('keyfile'),
5233            name=d.get('name'),
5234            scopes=d.get('scopes'),
5235            secret_store_id=d.get('secret_store_id'),
5236            tags=d.get('tags'),
5237        )
GCP( bind_interface=None, egress_filter=None, healthy=None, id=None, keyfile=None, name=None, scopes=None, secret_store_id=None, tags=None)
5150    def __init__(
5151        self,
5152        bind_interface=None,
5153        egress_filter=None,
5154        healthy=None,
5155        id=None,
5156        keyfile=None,
5157        name=None,
5158        scopes=None,
5159        secret_store_id=None,
5160        tags=None,
5161    ):
5162        self.bind_interface = bind_interface if bind_interface is not None else ''
5163        '''
5164         Bind interface
5165        '''
5166        self.egress_filter = egress_filter if egress_filter is not None else ''
5167        '''
5168         A filter applied to the routing logic to pin datasource to nodes.
5169        '''
5170        self.healthy = healthy if healthy is not None else False
5171        '''
5172         True if the datasource is reachable and the credentials are valid.
5173        '''
5174        self.id = id if id is not None else ''
5175        '''
5176         Unique identifier of the Resource.
5177        '''
5178        self.keyfile = keyfile if keyfile is not None else ''
5179        '''
5180
5181        '''
5182        self.name = name if name is not None else ''
5183        '''
5184         Unique human-readable name of the Resource.
5185        '''
5186        self.scopes = scopes if scopes is not None else ''
5187        '''
5188
5189        '''
5190        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5191        '''
5192         ID of the secret store containing credentials for this resource, if any.
5193        '''
5194        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5195        '''
5196         Tags is a map of key, value pairs.
5197        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

keyfile
name

Unique human-readable name of the Resource.

scopes
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
5212    def to_dict(self):
5213        return {
5214            'bind_interface': self.bind_interface,
5215            'egress_filter': self.egress_filter,
5216            'healthy': self.healthy,
5217            'id': self.id,
5218            'keyfile': self.keyfile,
5219            'name': self.name,
5220            'scopes': self.scopes,
5221            'secret_store_id': self.secret_store_id,
5222            'tags': self.tags,
5223        }
@classmethod
def from_dict(cls, d)
5225    @classmethod
5226    def from_dict(cls, d):
5227        return cls(
5228            bind_interface=d.get('bind_interface'),
5229            egress_filter=d.get('egress_filter'),
5230            healthy=d.get('healthy'),
5231            id=d.get('id'),
5232            keyfile=d.get('keyfile'),
5233            name=d.get('name'),
5234            scopes=d.get('scopes'),
5235            secret_store_id=d.get('secret_store_id'),
5236            tags=d.get('tags'),
5237        )
class GCPStore:
5240class GCPStore:
5241    '''
5242
5243    '''
5244    __slots__ = [
5245        'id',
5246        'name',
5247        'projectid',
5248        'tags',
5249    ]
5250
5251    def __init__(
5252        self,
5253        id=None,
5254        name=None,
5255        projectid=None,
5256        tags=None,
5257    ):
5258        self.id = id if id is not None else ''
5259        '''
5260         Unique identifier of the SecretStore.
5261        '''
5262        self.name = name if name is not None else ''
5263        '''
5264         Unique human-readable name of the SecretStore.
5265        '''
5266        self.projectid = projectid if projectid is not None else ''
5267        '''
5268
5269        '''
5270        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5271        '''
5272         Tags is a map of key, value pairs.
5273        '''
5274
5275    def __repr__(self):
5276        return '<sdm.GCPStore ' + \
5277            'id: ' + repr(self.id) + ' ' +\
5278            'name: ' + repr(self.name) + ' ' +\
5279            'projectid: ' + repr(self.projectid) + ' ' +\
5280            'tags: ' + repr(self.tags) + ' ' +\
5281            '>'
5282
5283    def to_dict(self):
5284        return {
5285            'id': self.id,
5286            'name': self.name,
5287            'projectid': self.projectid,
5288            'tags': self.tags,
5289        }
5290
5291    @classmethod
5292    def from_dict(cls, d):
5293        return cls(
5294            id=d.get('id'),
5295            name=d.get('name'),
5296            projectid=d.get('projectid'),
5297            tags=d.get('tags'),
5298        )
GCPStore(id=None, name=None, projectid=None, tags=None)
5251    def __init__(
5252        self,
5253        id=None,
5254        name=None,
5255        projectid=None,
5256        tags=None,
5257    ):
5258        self.id = id if id is not None else ''
5259        '''
5260         Unique identifier of the SecretStore.
5261        '''
5262        self.name = name if name is not None else ''
5263        '''
5264         Unique human-readable name of the SecretStore.
5265        '''
5266        self.projectid = projectid if projectid is not None else ''
5267        '''
5268
5269        '''
5270        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5271        '''
5272         Tags is a map of key, value pairs.
5273        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

projectid
tags

Tags is a map of key, value pairs.

def to_dict(self)
5283    def to_dict(self):
5284        return {
5285            'id': self.id,
5286            'name': self.name,
5287            'projectid': self.projectid,
5288            'tags': self.tags,
5289        }
@classmethod
def from_dict(cls, d)
5291    @classmethod
5292    def from_dict(cls, d):
5293        return cls(
5294            id=d.get('id'),
5295            name=d.get('name'),
5296            projectid=d.get('projectid'),
5297            tags=d.get('tags'),
5298        )
class Gateway:
5301class Gateway:
5302    '''
5303     Gateway represents a StrongDM CLI installation running in gateway mode.
5304    '''
5305    __slots__ = [
5306        'bind_address',
5307        'gateway_filter',
5308        'id',
5309        'listen_address',
5310        'name',
5311        'state',
5312        'tags',
5313    ]
5314
5315    def __init__(
5316        self,
5317        bind_address=None,
5318        gateway_filter=None,
5319        id=None,
5320        listen_address=None,
5321        name=None,
5322        state=None,
5323        tags=None,
5324    ):
5325        self.bind_address = bind_address if bind_address is not None else ''
5326        '''
5327         The hostname/port tuple which the gateway daemon will bind to.
5328         If not provided on create, set to "0.0.0.0:listen_address_port".
5329        '''
5330        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
5331        '''
5332         GatewayFilter can be used to restrict the peering between relays and
5333         gateways.
5334        '''
5335        self.id = id if id is not None else ''
5336        '''
5337         Unique identifier of the Gateway.
5338        '''
5339        self.listen_address = listen_address if listen_address is not None else ''
5340        '''
5341         The public hostname/port tuple at which the gateway will be accessible to clients.
5342        '''
5343        self.name = name if name is not None else ''
5344        '''
5345         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
5346        '''
5347        self.state = state if state is not None else ''
5348        '''
5349         The current state of the gateway. One of: "new", "verifying_restart",
5350         "restarting", "started", "stopped", "dead", "unknown"
5351        '''
5352        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5353        '''
5354         Tags is a map of key, value pairs.
5355        '''
5356
5357    def __repr__(self):
5358        return '<sdm.Gateway ' + \
5359            'bind_address: ' + repr(self.bind_address) + ' ' +\
5360            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
5361            'id: ' + repr(self.id) + ' ' +\
5362            'listen_address: ' + repr(self.listen_address) + ' ' +\
5363            'name: ' + repr(self.name) + ' ' +\
5364            'state: ' + repr(self.state) + ' ' +\
5365            'tags: ' + repr(self.tags) + ' ' +\
5366            '>'
5367
5368    def to_dict(self):
5369        return {
5370            'bind_address': self.bind_address,
5371            'gateway_filter': self.gateway_filter,
5372            'id': self.id,
5373            'listen_address': self.listen_address,
5374            'name': self.name,
5375            'state': self.state,
5376            'tags': self.tags,
5377        }
5378
5379    @classmethod
5380    def from_dict(cls, d):
5381        return cls(
5382            bind_address=d.get('bind_address'),
5383            gateway_filter=d.get('gateway_filter'),
5384            id=d.get('id'),
5385            listen_address=d.get('listen_address'),
5386            name=d.get('name'),
5387            state=d.get('state'),
5388            tags=d.get('tags'),
5389        )

Gateway represents a StrongDM CLI installation running in gateway mode.

Gateway( bind_address=None, gateway_filter=None, id=None, listen_address=None, name=None, state=None, tags=None)
5315    def __init__(
5316        self,
5317        bind_address=None,
5318        gateway_filter=None,
5319        id=None,
5320        listen_address=None,
5321        name=None,
5322        state=None,
5323        tags=None,
5324    ):
5325        self.bind_address = bind_address if bind_address is not None else ''
5326        '''
5327         The hostname/port tuple which the gateway daemon will bind to.
5328         If not provided on create, set to "0.0.0.0:listen_address_port".
5329        '''
5330        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
5331        '''
5332         GatewayFilter can be used to restrict the peering between relays and
5333         gateways.
5334        '''
5335        self.id = id if id is not None else ''
5336        '''
5337         Unique identifier of the Gateway.
5338        '''
5339        self.listen_address = listen_address if listen_address is not None else ''
5340        '''
5341         The public hostname/port tuple at which the gateway will be accessible to clients.
5342        '''
5343        self.name = name if name is not None else ''
5344        '''
5345         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
5346        '''
5347        self.state = state if state is not None else ''
5348        '''
5349         The current state of the gateway. One of: "new", "verifying_restart",
5350         "restarting", "started", "stopped", "dead", "unknown"
5351        '''
5352        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5353        '''
5354         Tags is a map of key, value pairs.
5355        '''
bind_address

The hostname/port tuple which the gateway daemon will bind to. If not provided on create, set to "0.0.0.0:listen_address_port".

gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Gateway.

listen_address

The public hostname/port tuple at which the gateway will be accessible to clients.

name

Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the gateway. One of: "new", "verifying_restart", "restarting", "started", "stopped", "dead", "unknown"

tags

Tags is a map of key, value pairs.

def to_dict(self)
5368    def to_dict(self):
5369        return {
5370            'bind_address': self.bind_address,
5371            'gateway_filter': self.gateway_filter,
5372            'id': self.id,
5373            'listen_address': self.listen_address,
5374            'name': self.name,
5375            'state': self.state,
5376            'tags': self.tags,
5377        }
@classmethod
def from_dict(cls, d)
5379    @classmethod
5380    def from_dict(cls, d):
5381        return cls(
5382            bind_address=d.get('bind_address'),
5383            gateway_filter=d.get('gateway_filter'),
5384            id=d.get('id'),
5385            listen_address=d.get('listen_address'),
5386            name=d.get('name'),
5387            state=d.get('state'),
5388            tags=d.get('tags'),
5389        )
class GetResponseMetadata:
5392class GetResponseMetadata:
5393    '''
5394     GetResponseMetadata is reserved for future use.
5395    '''
5396    __slots__ = []
5397
5398    def __init__(self, ):
5399        pass
5400
5401    def __repr__(self):
5402        return '<sdm.GetResponseMetadata ' + \
5403            '>'
5404
5405    def to_dict(self):
5406        return {}
5407
5408    @classmethod
5409    def from_dict(cls, d):
5410        return cls()

GetResponseMetadata is reserved for future use.

GetResponseMetadata()
5398    def __init__(self, ):
5399        pass
def to_dict(self)
5405    def to_dict(self):
5406        return {}
@classmethod
def from_dict(cls, d)
5408    @classmethod
5409    def from_dict(cls, d):
5410        return cls()
class GoogleGKE:
5413class GoogleGKE:
5414    '''
5415
5416    '''
5417    __slots__ = [
5418        'bind_interface',
5419        'certificate_authority',
5420        'egress_filter',
5421        'endpoint',
5422        'healthcheck_namespace',
5423        'healthy',
5424        'id',
5425        'name',
5426        'remote_identity_group_id',
5427        'remote_identity_healthcheck_username',
5428        'secret_store_id',
5429        'service_account_key',
5430        'tags',
5431    ]
5432
5433    def __init__(
5434        self,
5435        bind_interface=None,
5436        certificate_authority=None,
5437        egress_filter=None,
5438        endpoint=None,
5439        healthcheck_namespace=None,
5440        healthy=None,
5441        id=None,
5442        name=None,
5443        remote_identity_group_id=None,
5444        remote_identity_healthcheck_username=None,
5445        secret_store_id=None,
5446        service_account_key=None,
5447        tags=None,
5448    ):
5449        self.bind_interface = bind_interface if bind_interface is not None else ''
5450        '''
5451         Bind interface
5452        '''
5453        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5454        '''
5455
5456        '''
5457        self.egress_filter = egress_filter if egress_filter is not None else ''
5458        '''
5459         A filter applied to the routing logic to pin datasource to nodes.
5460        '''
5461        self.endpoint = endpoint if endpoint is not None else ''
5462        '''
5463
5464        '''
5465        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5466        '''
5467         The path used to check the health of your connection.  Defaults to `default`.
5468        '''
5469        self.healthy = healthy if healthy is not None else False
5470        '''
5471         True if the datasource is reachable and the credentials are valid.
5472        '''
5473        self.id = id if id is not None else ''
5474        '''
5475         Unique identifier of the Resource.
5476        '''
5477        self.name = name if name is not None else ''
5478        '''
5479         Unique human-readable name of the Resource.
5480        '''
5481        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5482        '''
5483
5484        '''
5485        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5486        '''
5487
5488        '''
5489        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5490        '''
5491         ID of the secret store containing credentials for this resource, if any.
5492        '''
5493        self.service_account_key = service_account_key if service_account_key is not None else ''
5494        '''
5495
5496        '''
5497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5498        '''
5499         Tags is a map of key, value pairs.
5500        '''
5501
5502    def __repr__(self):
5503        return '<sdm.GoogleGKE ' + \
5504            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5505            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5506            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5507            'endpoint: ' + repr(self.endpoint) + ' ' +\
5508            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5509            'healthy: ' + repr(self.healthy) + ' ' +\
5510            'id: ' + repr(self.id) + ' ' +\
5511            'name: ' + repr(self.name) + ' ' +\
5512            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
5513            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
5514            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5515            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5516            'tags: ' + repr(self.tags) + ' ' +\
5517            '>'
5518
5519    def to_dict(self):
5520        return {
5521            'bind_interface': self.bind_interface,
5522            'certificate_authority': self.certificate_authority,
5523            'egress_filter': self.egress_filter,
5524            'endpoint': self.endpoint,
5525            'healthcheck_namespace': self.healthcheck_namespace,
5526            'healthy': self.healthy,
5527            'id': self.id,
5528            'name': self.name,
5529            'remote_identity_group_id': self.remote_identity_group_id,
5530            'remote_identity_healthcheck_username':
5531            self.remote_identity_healthcheck_username,
5532            'secret_store_id': self.secret_store_id,
5533            'service_account_key': self.service_account_key,
5534            'tags': self.tags,
5535        }
5536
5537    @classmethod
5538    def from_dict(cls, d):
5539        return cls(
5540            bind_interface=d.get('bind_interface'),
5541            certificate_authority=d.get('certificate_authority'),
5542            egress_filter=d.get('egress_filter'),
5543            endpoint=d.get('endpoint'),
5544            healthcheck_namespace=d.get('healthcheck_namespace'),
5545            healthy=d.get('healthy'),
5546            id=d.get('id'),
5547            name=d.get('name'),
5548            remote_identity_group_id=d.get('remote_identity_group_id'),
5549            remote_identity_healthcheck_username=d.get(
5550                'remote_identity_healthcheck_username'),
5551            secret_store_id=d.get('secret_store_id'),
5552            service_account_key=d.get('service_account_key'),
5553            tags=d.get('tags'),
5554        )
GoogleGKE( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, service_account_key=None, tags=None)
5433    def __init__(
5434        self,
5435        bind_interface=None,
5436        certificate_authority=None,
5437        egress_filter=None,
5438        endpoint=None,
5439        healthcheck_namespace=None,
5440        healthy=None,
5441        id=None,
5442        name=None,
5443        remote_identity_group_id=None,
5444        remote_identity_healthcheck_username=None,
5445        secret_store_id=None,
5446        service_account_key=None,
5447        tags=None,
5448    ):
5449        self.bind_interface = bind_interface if bind_interface is not None else ''
5450        '''
5451         Bind interface
5452        '''
5453        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5454        '''
5455
5456        '''
5457        self.egress_filter = egress_filter if egress_filter is not None else ''
5458        '''
5459         A filter applied to the routing logic to pin datasource to nodes.
5460        '''
5461        self.endpoint = endpoint if endpoint is not None else ''
5462        '''
5463
5464        '''
5465        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5466        '''
5467         The path used to check the health of your connection.  Defaults to `default`.
5468        '''
5469        self.healthy = healthy if healthy is not None else False
5470        '''
5471         True if the datasource is reachable and the credentials are valid.
5472        '''
5473        self.id = id if id is not None else ''
5474        '''
5475         Unique identifier of the Resource.
5476        '''
5477        self.name = name if name is not None else ''
5478        '''
5479         Unique human-readable name of the Resource.
5480        '''
5481        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5482        '''
5483
5484        '''
5485        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5486        '''
5487
5488        '''
5489        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5490        '''
5491         ID of the secret store containing credentials for this resource, if any.
5492        '''
5493        self.service_account_key = service_account_key if service_account_key is not None else ''
5494        '''
5495
5496        '''
5497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5498        '''
5499         Tags is a map of key, value pairs.
5500        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5519    def to_dict(self):
5520        return {
5521            'bind_interface': self.bind_interface,
5522            'certificate_authority': self.certificate_authority,
5523            'egress_filter': self.egress_filter,
5524            'endpoint': self.endpoint,
5525            'healthcheck_namespace': self.healthcheck_namespace,
5526            'healthy': self.healthy,
5527            'id': self.id,
5528            'name': self.name,
5529            'remote_identity_group_id': self.remote_identity_group_id,
5530            'remote_identity_healthcheck_username':
5531            self.remote_identity_healthcheck_username,
5532            'secret_store_id': self.secret_store_id,
5533            'service_account_key': self.service_account_key,
5534            'tags': self.tags,
5535        }
@classmethod
def from_dict(cls, d)
5537    @classmethod
5538    def from_dict(cls, d):
5539        return cls(
5540            bind_interface=d.get('bind_interface'),
5541            certificate_authority=d.get('certificate_authority'),
5542            egress_filter=d.get('egress_filter'),
5543            endpoint=d.get('endpoint'),
5544            healthcheck_namespace=d.get('healthcheck_namespace'),
5545            healthy=d.get('healthy'),
5546            id=d.get('id'),
5547            name=d.get('name'),
5548            remote_identity_group_id=d.get('remote_identity_group_id'),
5549            remote_identity_healthcheck_username=d.get(
5550                'remote_identity_healthcheck_username'),
5551            secret_store_id=d.get('secret_store_id'),
5552            service_account_key=d.get('service_account_key'),
5553            tags=d.get('tags'),
5554        )
class GoogleGKEUserImpersonation:
5557class GoogleGKEUserImpersonation:
5558    '''
5559
5560    '''
5561    __slots__ = [
5562        'bind_interface',
5563        'certificate_authority',
5564        'egress_filter',
5565        'endpoint',
5566        'healthcheck_namespace',
5567        'healthy',
5568        'id',
5569        'name',
5570        'secret_store_id',
5571        'service_account_key',
5572        'tags',
5573    ]
5574
5575    def __init__(
5576        self,
5577        bind_interface=None,
5578        certificate_authority=None,
5579        egress_filter=None,
5580        endpoint=None,
5581        healthcheck_namespace=None,
5582        healthy=None,
5583        id=None,
5584        name=None,
5585        secret_store_id=None,
5586        service_account_key=None,
5587        tags=None,
5588    ):
5589        self.bind_interface = bind_interface if bind_interface is not None else ''
5590        '''
5591         Bind interface
5592        '''
5593        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5594        '''
5595
5596        '''
5597        self.egress_filter = egress_filter if egress_filter is not None else ''
5598        '''
5599         A filter applied to the routing logic to pin datasource to nodes.
5600        '''
5601        self.endpoint = endpoint if endpoint is not None else ''
5602        '''
5603
5604        '''
5605        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5606        '''
5607         The path used to check the health of your connection.  Defaults to `default`.
5608        '''
5609        self.healthy = healthy if healthy is not None else False
5610        '''
5611         True if the datasource is reachable and the credentials are valid.
5612        '''
5613        self.id = id if id is not None else ''
5614        '''
5615         Unique identifier of the Resource.
5616        '''
5617        self.name = name if name is not None else ''
5618        '''
5619         Unique human-readable name of the Resource.
5620        '''
5621        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5622        '''
5623         ID of the secret store containing credentials for this resource, if any.
5624        '''
5625        self.service_account_key = service_account_key if service_account_key is not None else ''
5626        '''
5627
5628        '''
5629        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5630        '''
5631         Tags is a map of key, value pairs.
5632        '''
5633
5634    def __repr__(self):
5635        return '<sdm.GoogleGKEUserImpersonation ' + \
5636            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5637            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5638            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5639            'endpoint: ' + repr(self.endpoint) + ' ' +\
5640            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5641            'healthy: ' + repr(self.healthy) + ' ' +\
5642            'id: ' + repr(self.id) + ' ' +\
5643            'name: ' + repr(self.name) + ' ' +\
5644            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5645            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5646            'tags: ' + repr(self.tags) + ' ' +\
5647            '>'
5648
5649    def to_dict(self):
5650        return {
5651            'bind_interface': self.bind_interface,
5652            'certificate_authority': self.certificate_authority,
5653            'egress_filter': self.egress_filter,
5654            'endpoint': self.endpoint,
5655            'healthcheck_namespace': self.healthcheck_namespace,
5656            'healthy': self.healthy,
5657            'id': self.id,
5658            'name': self.name,
5659            'secret_store_id': self.secret_store_id,
5660            'service_account_key': self.service_account_key,
5661            'tags': self.tags,
5662        }
5663
5664    @classmethod
5665    def from_dict(cls, d):
5666        return cls(
5667            bind_interface=d.get('bind_interface'),
5668            certificate_authority=d.get('certificate_authority'),
5669            egress_filter=d.get('egress_filter'),
5670            endpoint=d.get('endpoint'),
5671            healthcheck_namespace=d.get('healthcheck_namespace'),
5672            healthy=d.get('healthy'),
5673            id=d.get('id'),
5674            name=d.get('name'),
5675            secret_store_id=d.get('secret_store_id'),
5676            service_account_key=d.get('service_account_key'),
5677            tags=d.get('tags'),
5678        )
GoogleGKEUserImpersonation( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, secret_store_id=None, service_account_key=None, tags=None)
5575    def __init__(
5576        self,
5577        bind_interface=None,
5578        certificate_authority=None,
5579        egress_filter=None,
5580        endpoint=None,
5581        healthcheck_namespace=None,
5582        healthy=None,
5583        id=None,
5584        name=None,
5585        secret_store_id=None,
5586        service_account_key=None,
5587        tags=None,
5588    ):
5589        self.bind_interface = bind_interface if bind_interface is not None else ''
5590        '''
5591         Bind interface
5592        '''
5593        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5594        '''
5595
5596        '''
5597        self.egress_filter = egress_filter if egress_filter is not None else ''
5598        '''
5599         A filter applied to the routing logic to pin datasource to nodes.
5600        '''
5601        self.endpoint = endpoint if endpoint is not None else ''
5602        '''
5603
5604        '''
5605        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5606        '''
5607         The path used to check the health of your connection.  Defaults to `default`.
5608        '''
5609        self.healthy = healthy if healthy is not None else False
5610        '''
5611         True if the datasource is reachable and the credentials are valid.
5612        '''
5613        self.id = id if id is not None else ''
5614        '''
5615         Unique identifier of the Resource.
5616        '''
5617        self.name = name if name is not None else ''
5618        '''
5619         Unique human-readable name of the Resource.
5620        '''
5621        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5622        '''
5623         ID of the secret store containing credentials for this resource, if any.
5624        '''
5625        self.service_account_key = service_account_key if service_account_key is not None else ''
5626        '''
5627
5628        '''
5629        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5630        '''
5631         Tags is a map of key, value pairs.
5632        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5649    def to_dict(self):
5650        return {
5651            'bind_interface': self.bind_interface,
5652            'certificate_authority': self.certificate_authority,
5653            'egress_filter': self.egress_filter,
5654            'endpoint': self.endpoint,
5655            'healthcheck_namespace': self.healthcheck_namespace,
5656            'healthy': self.healthy,
5657            'id': self.id,
5658            'name': self.name,
5659            'secret_store_id': self.secret_store_id,
5660            'service_account_key': self.service_account_key,
5661            'tags': self.tags,
5662        }
@classmethod
def from_dict(cls, d)
5664    @classmethod
5665    def from_dict(cls, d):
5666        return cls(
5667            bind_interface=d.get('bind_interface'),
5668            certificate_authority=d.get('certificate_authority'),
5669            egress_filter=d.get('egress_filter'),
5670            endpoint=d.get('endpoint'),
5671            healthcheck_namespace=d.get('healthcheck_namespace'),
5672            healthy=d.get('healthy'),
5673            id=d.get('id'),
5674            name=d.get('name'),
5675            secret_store_id=d.get('secret_store_id'),
5676            service_account_key=d.get('service_account_key'),
5677            tags=d.get('tags'),
5678        )
class Greenplum:
5681class Greenplum:
5682    '''
5683
5684    '''
5685    __slots__ = [
5686        'bind_interface',
5687        'database',
5688        'egress_filter',
5689        'healthy',
5690        'hostname',
5691        'id',
5692        'name',
5693        'override_database',
5694        'password',
5695        'port',
5696        'port_override',
5697        'secret_store_id',
5698        'tags',
5699        'username',
5700    ]
5701
5702    def __init__(
5703        self,
5704        bind_interface=None,
5705        database=None,
5706        egress_filter=None,
5707        healthy=None,
5708        hostname=None,
5709        id=None,
5710        name=None,
5711        override_database=None,
5712        password=None,
5713        port=None,
5714        port_override=None,
5715        secret_store_id=None,
5716        tags=None,
5717        username=None,
5718    ):
5719        self.bind_interface = bind_interface if bind_interface is not None else ''
5720        '''
5721         Bind interface
5722        '''
5723        self.database = database if database is not None else ''
5724        '''
5725
5726        '''
5727        self.egress_filter = egress_filter if egress_filter is not None else ''
5728        '''
5729         A filter applied to the routing logic to pin datasource to nodes.
5730        '''
5731        self.healthy = healthy if healthy is not None else False
5732        '''
5733         True if the datasource is reachable and the credentials are valid.
5734        '''
5735        self.hostname = hostname if hostname is not None else ''
5736        '''
5737
5738        '''
5739        self.id = id if id is not None else ''
5740        '''
5741         Unique identifier of the Resource.
5742        '''
5743        self.name = name if name is not None else ''
5744        '''
5745         Unique human-readable name of the Resource.
5746        '''
5747        self.override_database = override_database if override_database is not None else False
5748        '''
5749
5750        '''
5751        self.password = password if password is not None else ''
5752        '''
5753
5754        '''
5755        self.port = port if port is not None else 0
5756        '''
5757
5758        '''
5759        self.port_override = port_override if port_override is not None else 0
5760        '''
5761
5762        '''
5763        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5764        '''
5765         ID of the secret store containing credentials for this resource, if any.
5766        '''
5767        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5768        '''
5769         Tags is a map of key, value pairs.
5770        '''
5771        self.username = username if username is not None else ''
5772        '''
5773
5774        '''
5775
5776    def __repr__(self):
5777        return '<sdm.Greenplum ' + \
5778            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5779            'database: ' + repr(self.database) + ' ' +\
5780            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5781            'healthy: ' + repr(self.healthy) + ' ' +\
5782            'hostname: ' + repr(self.hostname) + ' ' +\
5783            'id: ' + repr(self.id) + ' ' +\
5784            'name: ' + repr(self.name) + ' ' +\
5785            'override_database: ' + repr(self.override_database) + ' ' +\
5786            'password: ' + repr(self.password) + ' ' +\
5787            'port: ' + repr(self.port) + ' ' +\
5788            'port_override: ' + repr(self.port_override) + ' ' +\
5789            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5790            'tags: ' + repr(self.tags) + ' ' +\
5791            'username: ' + repr(self.username) + ' ' +\
5792            '>'
5793
5794    def to_dict(self):
5795        return {
5796            'bind_interface': self.bind_interface,
5797            'database': self.database,
5798            'egress_filter': self.egress_filter,
5799            'healthy': self.healthy,
5800            'hostname': self.hostname,
5801            'id': self.id,
5802            'name': self.name,
5803            'override_database': self.override_database,
5804            'password': self.password,
5805            'port': self.port,
5806            'port_override': self.port_override,
5807            'secret_store_id': self.secret_store_id,
5808            'tags': self.tags,
5809            'username': self.username,
5810        }
5811
5812    @classmethod
5813    def from_dict(cls, d):
5814        return cls(
5815            bind_interface=d.get('bind_interface'),
5816            database=d.get('database'),
5817            egress_filter=d.get('egress_filter'),
5818            healthy=d.get('healthy'),
5819            hostname=d.get('hostname'),
5820            id=d.get('id'),
5821            name=d.get('name'),
5822            override_database=d.get('override_database'),
5823            password=d.get('password'),
5824            port=d.get('port'),
5825            port_override=d.get('port_override'),
5826            secret_store_id=d.get('secret_store_id'),
5827            tags=d.get('tags'),
5828            username=d.get('username'),
5829        )
Greenplum( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
5702    def __init__(
5703        self,
5704        bind_interface=None,
5705        database=None,
5706        egress_filter=None,
5707        healthy=None,
5708        hostname=None,
5709        id=None,
5710        name=None,
5711        override_database=None,
5712        password=None,
5713        port=None,
5714        port_override=None,
5715        secret_store_id=None,
5716        tags=None,
5717        username=None,
5718    ):
5719        self.bind_interface = bind_interface if bind_interface is not None else ''
5720        '''
5721         Bind interface
5722        '''
5723        self.database = database if database is not None else ''
5724        '''
5725
5726        '''
5727        self.egress_filter = egress_filter if egress_filter is not None else ''
5728        '''
5729         A filter applied to the routing logic to pin datasource to nodes.
5730        '''
5731        self.healthy = healthy if healthy is not None else False
5732        '''
5733         True if the datasource is reachable and the credentials are valid.
5734        '''
5735        self.hostname = hostname if hostname is not None else ''
5736        '''
5737
5738        '''
5739        self.id = id if id is not None else ''
5740        '''
5741         Unique identifier of the Resource.
5742        '''
5743        self.name = name if name is not None else ''
5744        '''
5745         Unique human-readable name of the Resource.
5746        '''
5747        self.override_database = override_database if override_database is not None else False
5748        '''
5749
5750        '''
5751        self.password = password if password is not None else ''
5752        '''
5753
5754        '''
5755        self.port = port if port is not None else 0
5756        '''
5757
5758        '''
5759        self.port_override = port_override if port_override is not None else 0
5760        '''
5761
5762        '''
5763        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5764        '''
5765         ID of the secret store containing credentials for this resource, if any.
5766        '''
5767        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5768        '''
5769         Tags is a map of key, value pairs.
5770        '''
5771        self.username = username if username is not None else ''
5772        '''
5773
5774        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
5794    def to_dict(self):
5795        return {
5796            'bind_interface': self.bind_interface,
5797            'database': self.database,
5798            'egress_filter': self.egress_filter,
5799            'healthy': self.healthy,
5800            'hostname': self.hostname,
5801            'id': self.id,
5802            'name': self.name,
5803            'override_database': self.override_database,
5804            'password': self.password,
5805            'port': self.port,
5806            'port_override': self.port_override,
5807            'secret_store_id': self.secret_store_id,
5808            'tags': self.tags,
5809            'username': self.username,
5810        }
@classmethod
def from_dict(cls, d)
5812    @classmethod
5813    def from_dict(cls, d):
5814        return cls(
5815            bind_interface=d.get('bind_interface'),
5816            database=d.get('database'),
5817            egress_filter=d.get('egress_filter'),
5818            healthy=d.get('healthy'),
5819            hostname=d.get('hostname'),
5820            id=d.get('id'),
5821            name=d.get('name'),
5822            override_database=d.get('override_database'),
5823            password=d.get('password'),
5824            port=d.get('port'),
5825            port_override=d.get('port_override'),
5826            secret_store_id=d.get('secret_store_id'),
5827            tags=d.get('tags'),
5828            username=d.get('username'),
5829        )
class HTTPAuth:
5832class HTTPAuth:
5833    '''
5834
5835    '''
5836    __slots__ = [
5837        'auth_header',
5838        'bind_interface',
5839        'default_path',
5840        'egress_filter',
5841        'headers_blacklist',
5842        'healthcheck_path',
5843        'healthy',
5844        'id',
5845        'name',
5846        'secret_store_id',
5847        'subdomain',
5848        'tags',
5849        'url',
5850    ]
5851
5852    def __init__(
5853        self,
5854        auth_header=None,
5855        bind_interface=None,
5856        default_path=None,
5857        egress_filter=None,
5858        headers_blacklist=None,
5859        healthcheck_path=None,
5860        healthy=None,
5861        id=None,
5862        name=None,
5863        secret_store_id=None,
5864        subdomain=None,
5865        tags=None,
5866        url=None,
5867    ):
5868        self.auth_header = auth_header if auth_header is not None else ''
5869        '''
5870
5871        '''
5872        self.bind_interface = bind_interface if bind_interface is not None else ''
5873        '''
5874         Bind interface
5875        '''
5876        self.default_path = default_path if default_path is not None else ''
5877        '''
5878
5879        '''
5880        self.egress_filter = egress_filter if egress_filter is not None else ''
5881        '''
5882         A filter applied to the routing logic to pin datasource to nodes.
5883        '''
5884        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5885        '''
5886
5887        '''
5888        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5889        '''
5890
5891        '''
5892        self.healthy = healthy if healthy is not None else False
5893        '''
5894         True if the datasource is reachable and the credentials are valid.
5895        '''
5896        self.id = id if id is not None else ''
5897        '''
5898         Unique identifier of the Resource.
5899        '''
5900        self.name = name if name is not None else ''
5901        '''
5902         Unique human-readable name of the Resource.
5903        '''
5904        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5905        '''
5906         ID of the secret store containing credentials for this resource, if any.
5907        '''
5908        self.subdomain = subdomain if subdomain is not None else ''
5909        '''
5910
5911        '''
5912        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5913        '''
5914         Tags is a map of key, value pairs.
5915        '''
5916        self.url = url if url is not None else ''
5917        '''
5918
5919        '''
5920
5921    def __repr__(self):
5922        return '<sdm.HTTPAuth ' + \
5923            'auth_header: ' + repr(self.auth_header) + ' ' +\
5924            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5925            'default_path: ' + repr(self.default_path) + ' ' +\
5926            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5927            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5928            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5929            'healthy: ' + repr(self.healthy) + ' ' +\
5930            'id: ' + repr(self.id) + ' ' +\
5931            'name: ' + repr(self.name) + ' ' +\
5932            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5933            'subdomain: ' + repr(self.subdomain) + ' ' +\
5934            'tags: ' + repr(self.tags) + ' ' +\
5935            'url: ' + repr(self.url) + ' ' +\
5936            '>'
5937
5938    def to_dict(self):
5939        return {
5940            'auth_header': self.auth_header,
5941            'bind_interface': self.bind_interface,
5942            'default_path': self.default_path,
5943            'egress_filter': self.egress_filter,
5944            'headers_blacklist': self.headers_blacklist,
5945            'healthcheck_path': self.healthcheck_path,
5946            'healthy': self.healthy,
5947            'id': self.id,
5948            'name': self.name,
5949            'secret_store_id': self.secret_store_id,
5950            'subdomain': self.subdomain,
5951            'tags': self.tags,
5952            'url': self.url,
5953        }
5954
5955    @classmethod
5956    def from_dict(cls, d):
5957        return cls(
5958            auth_header=d.get('auth_header'),
5959            bind_interface=d.get('bind_interface'),
5960            default_path=d.get('default_path'),
5961            egress_filter=d.get('egress_filter'),
5962            headers_blacklist=d.get('headers_blacklist'),
5963            healthcheck_path=d.get('healthcheck_path'),
5964            healthy=d.get('healthy'),
5965            id=d.get('id'),
5966            name=d.get('name'),
5967            secret_store_id=d.get('secret_store_id'),
5968            subdomain=d.get('subdomain'),
5969            tags=d.get('tags'),
5970            url=d.get('url'),
5971        )
HTTPAuth( auth_header=None, bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
5852    def __init__(
5853        self,
5854        auth_header=None,
5855        bind_interface=None,
5856        default_path=None,
5857        egress_filter=None,
5858        headers_blacklist=None,
5859        healthcheck_path=None,
5860        healthy=None,
5861        id=None,
5862        name=None,
5863        secret_store_id=None,
5864        subdomain=None,
5865        tags=None,
5866        url=None,
5867    ):
5868        self.auth_header = auth_header if auth_header is not None else ''
5869        '''
5870
5871        '''
5872        self.bind_interface = bind_interface if bind_interface is not None else ''
5873        '''
5874         Bind interface
5875        '''
5876        self.default_path = default_path if default_path is not None else ''
5877        '''
5878
5879        '''
5880        self.egress_filter = egress_filter if egress_filter is not None else ''
5881        '''
5882         A filter applied to the routing logic to pin datasource to nodes.
5883        '''
5884        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5885        '''
5886
5887        '''
5888        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5889        '''
5890
5891        '''
5892        self.healthy = healthy if healthy is not None else False
5893        '''
5894         True if the datasource is reachable and the credentials are valid.
5895        '''
5896        self.id = id if id is not None else ''
5897        '''
5898         Unique identifier of the Resource.
5899        '''
5900        self.name = name if name is not None else ''
5901        '''
5902         Unique human-readable name of the Resource.
5903        '''
5904        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5905        '''
5906         ID of the secret store containing credentials for this resource, if any.
5907        '''
5908        self.subdomain = subdomain if subdomain is not None else ''
5909        '''
5910
5911        '''
5912        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5913        '''
5914         Tags is a map of key, value pairs.
5915        '''
5916        self.url = url if url is not None else ''
5917        '''
5918
5919        '''
auth_header
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
5938    def to_dict(self):
5939        return {
5940            'auth_header': self.auth_header,
5941            'bind_interface': self.bind_interface,
5942            'default_path': self.default_path,
5943            'egress_filter': self.egress_filter,
5944            'headers_blacklist': self.headers_blacklist,
5945            'healthcheck_path': self.healthcheck_path,
5946            'healthy': self.healthy,
5947            'id': self.id,
5948            'name': self.name,
5949            'secret_store_id': self.secret_store_id,
5950            'subdomain': self.subdomain,
5951            'tags': self.tags,
5952            'url': self.url,
5953        }
@classmethod
def from_dict(cls, d)
5955    @classmethod
5956    def from_dict(cls, d):
5957        return cls(
5958            auth_header=d.get('auth_header'),
5959            bind_interface=d.get('bind_interface'),
5960            default_path=d.get('default_path'),
5961            egress_filter=d.get('egress_filter'),
5962            headers_blacklist=d.get('headers_blacklist'),
5963            healthcheck_path=d.get('healthcheck_path'),
5964            healthy=d.get('healthy'),
5965            id=d.get('id'),
5966            name=d.get('name'),
5967            secret_store_id=d.get('secret_store_id'),
5968            subdomain=d.get('subdomain'),
5969            tags=d.get('tags'),
5970            url=d.get('url'),
5971        )
class HTTPBasicAuth:
5974class HTTPBasicAuth:
5975    '''
5976
5977    '''
5978    __slots__ = [
5979        'bind_interface',
5980        'default_path',
5981        'egress_filter',
5982        'headers_blacklist',
5983        'healthcheck_path',
5984        'healthy',
5985        'id',
5986        'name',
5987        'password',
5988        'secret_store_id',
5989        'subdomain',
5990        'tags',
5991        'url',
5992        'username',
5993    ]
5994
5995    def __init__(
5996        self,
5997        bind_interface=None,
5998        default_path=None,
5999        egress_filter=None,
6000        headers_blacklist=None,
6001        healthcheck_path=None,
6002        healthy=None,
6003        id=None,
6004        name=None,
6005        password=None,
6006        secret_store_id=None,
6007        subdomain=None,
6008        tags=None,
6009        url=None,
6010        username=None,
6011    ):
6012        self.bind_interface = bind_interface if bind_interface is not None else ''
6013        '''
6014         Bind interface
6015        '''
6016        self.default_path = default_path if default_path is not None else ''
6017        '''
6018
6019        '''
6020        self.egress_filter = egress_filter if egress_filter is not None else ''
6021        '''
6022         A filter applied to the routing logic to pin datasource to nodes.
6023        '''
6024        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6025        '''
6026
6027        '''
6028        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6029        '''
6030
6031        '''
6032        self.healthy = healthy if healthy is not None else False
6033        '''
6034         True if the datasource is reachable and the credentials are valid.
6035        '''
6036        self.id = id if id is not None else ''
6037        '''
6038         Unique identifier of the Resource.
6039        '''
6040        self.name = name if name is not None else ''
6041        '''
6042         Unique human-readable name of the Resource.
6043        '''
6044        self.password = password if password is not None else ''
6045        '''
6046
6047        '''
6048        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6049        '''
6050         ID of the secret store containing credentials for this resource, if any.
6051        '''
6052        self.subdomain = subdomain if subdomain is not None else ''
6053        '''
6054
6055        '''
6056        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6057        '''
6058         Tags is a map of key, value pairs.
6059        '''
6060        self.url = url if url is not None else ''
6061        '''
6062
6063        '''
6064        self.username = username if username is not None else ''
6065        '''
6066
6067        '''
6068
6069    def __repr__(self):
6070        return '<sdm.HTTPBasicAuth ' + \
6071            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6072            'default_path: ' + repr(self.default_path) + ' ' +\
6073            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6074            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
6075            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
6076            'healthy: ' + repr(self.healthy) + ' ' +\
6077            'id: ' + repr(self.id) + ' ' +\
6078            'name: ' + repr(self.name) + ' ' +\
6079            'password: ' + repr(self.password) + ' ' +\
6080            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6081            'subdomain: ' + repr(self.subdomain) + ' ' +\
6082            'tags: ' + repr(self.tags) + ' ' +\
6083            'url: ' + repr(self.url) + ' ' +\
6084            'username: ' + repr(self.username) + ' ' +\
6085            '>'
6086
6087    def to_dict(self):
6088        return {
6089            'bind_interface': self.bind_interface,
6090            'default_path': self.default_path,
6091            'egress_filter': self.egress_filter,
6092            'headers_blacklist': self.headers_blacklist,
6093            'healthcheck_path': self.healthcheck_path,
6094            'healthy': self.healthy,
6095            'id': self.id,
6096            'name': self.name,
6097            'password': self.password,
6098            'secret_store_id': self.secret_store_id,
6099            'subdomain': self.subdomain,
6100            'tags': self.tags,
6101            'url': self.url,
6102            'username': self.username,
6103        }
6104
6105    @classmethod
6106    def from_dict(cls, d):
6107        return cls(
6108            bind_interface=d.get('bind_interface'),
6109            default_path=d.get('default_path'),
6110            egress_filter=d.get('egress_filter'),
6111            headers_blacklist=d.get('headers_blacklist'),
6112            healthcheck_path=d.get('healthcheck_path'),
6113            healthy=d.get('healthy'),
6114            id=d.get('id'),
6115            name=d.get('name'),
6116            password=d.get('password'),
6117            secret_store_id=d.get('secret_store_id'),
6118            subdomain=d.get('subdomain'),
6119            tags=d.get('tags'),
6120            url=d.get('url'),
6121            username=d.get('username'),
6122        )
HTTPBasicAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, subdomain=None, tags=None, url=None, username=None)
5995    def __init__(
5996        self,
5997        bind_interface=None,
5998        default_path=None,
5999        egress_filter=None,
6000        headers_blacklist=None,
6001        healthcheck_path=None,
6002        healthy=None,
6003        id=None,
6004        name=None,
6005        password=None,
6006        secret_store_id=None,
6007        subdomain=None,
6008        tags=None,
6009        url=None,
6010        username=None,
6011    ):
6012        self.bind_interface = bind_interface if bind_interface is not None else ''
6013        '''
6014         Bind interface
6015        '''
6016        self.default_path = default_path if default_path is not None else ''
6017        '''
6018
6019        '''
6020        self.egress_filter = egress_filter if egress_filter is not None else ''
6021        '''
6022         A filter applied to the routing logic to pin datasource to nodes.
6023        '''
6024        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6025        '''
6026
6027        '''
6028        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6029        '''
6030
6031        '''
6032        self.healthy = healthy if healthy is not None else False
6033        '''
6034         True if the datasource is reachable and the credentials are valid.
6035        '''
6036        self.id = id if id is not None else ''
6037        '''
6038         Unique identifier of the Resource.
6039        '''
6040        self.name = name if name is not None else ''
6041        '''
6042         Unique human-readable name of the Resource.
6043        '''
6044        self.password = password if password is not None else ''
6045        '''
6046
6047        '''
6048        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6049        '''
6050         ID of the secret store containing credentials for this resource, if any.
6051        '''
6052        self.subdomain = subdomain if subdomain is not None else ''
6053        '''
6054
6055        '''
6056        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6057        '''
6058         Tags is a map of key, value pairs.
6059        '''
6060        self.url = url if url is not None else ''
6061        '''
6062
6063        '''
6064        self.username = username if username is not None else ''
6065        '''
6066
6067        '''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
username
def to_dict(self)
6087    def to_dict(self):
6088        return {
6089            'bind_interface': self.bind_interface,
6090            'default_path': self.default_path,
6091            'egress_filter': self.egress_filter,
6092            'headers_blacklist': self.headers_blacklist,
6093            'healthcheck_path': self.healthcheck_path,
6094            'healthy': self.healthy,
6095            'id': self.id,
6096            'name': self.name,
6097            'password': self.password,
6098            'secret_store_id': self.secret_store_id,
6099            'subdomain': self.subdomain,
6100            'tags': self.tags,
6101            'url': self.url,
6102            'username': self.username,
6103        }
@classmethod
def from_dict(cls, d)
6105    @classmethod
6106    def from_dict(cls, d):
6107        return cls(
6108            bind_interface=d.get('bind_interface'),
6109            default_path=d.get('default_path'),
6110            egress_filter=d.get('egress_filter'),
6111            headers_blacklist=d.get('headers_blacklist'),
6112            healthcheck_path=d.get('healthcheck_path'),
6113            healthy=d.get('healthy'),
6114            id=d.get('id'),
6115            name=d.get('name'),
6116            password=d.get('password'),
6117            secret_store_id=d.get('secret_store_id'),
6118            subdomain=d.get('subdomain'),
6119            tags=d.get('tags'),
6120            url=d.get('url'),
6121            username=d.get('username'),
6122        )
class HTTPNoAuth:
6125class HTTPNoAuth:
6126    '''
6127
6128    '''
6129    __slots__ = [
6130        'bind_interface',
6131        'default_path',
6132        'egress_filter',
6133        'headers_blacklist',
6134        'healthcheck_path',
6135        'healthy',
6136        'id',
6137        'name',
6138        'secret_store_id',
6139        'subdomain',
6140        'tags',
6141        'url',
6142    ]
6143
6144    def __init__(
6145        self,
6146        bind_interface=None,
6147        default_path=None,
6148        egress_filter=None,
6149        headers_blacklist=None,
6150        healthcheck_path=None,
6151        healthy=None,
6152        id=None,
6153        name=None,
6154        secret_store_id=None,
6155        subdomain=None,
6156        tags=None,
6157        url=None,
6158    ):
6159        self.bind_interface = bind_interface if bind_interface is not None else ''
6160        '''
6161         Bind interface
6162        '''
6163        self.default_path = default_path if default_path is not None else ''
6164        '''
6165
6166        '''
6167        self.egress_filter = egress_filter if egress_filter is not None else ''
6168        '''
6169         A filter applied to the routing logic to pin datasource to nodes.
6170        '''
6171        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6172        '''
6173
6174        '''
6175        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6176        '''
6177
6178        '''
6179        self.healthy = healthy if healthy is not None else False
6180        '''
6181         True if the datasource is reachable and the credentials are valid.
6182        '''
6183        self.id = id if id is not None else ''
6184        '''
6185         Unique identifier of the Resource.
6186        '''
6187        self.name = name if name is not None else ''
6188        '''
6189         Unique human-readable name of the Resource.
6190        '''
6191        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6192        '''
6193         ID of the secret store containing credentials for this resource, if any.
6194        '''
6195        self.subdomain = subdomain if subdomain is not None else ''
6196        '''
6197
6198        '''
6199        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6200        '''
6201         Tags is a map of key, value pairs.
6202        '''
6203        self.url = url if url is not None else ''
6204        '''
6205
6206        '''
6207
6208    def __repr__(self):
6209        return '<sdm.HTTPNoAuth ' + \
6210            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6211            'default_path: ' + repr(self.default_path) + ' ' +\
6212            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6213            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
6214            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
6215            'healthy: ' + repr(self.healthy) + ' ' +\
6216            'id: ' + repr(self.id) + ' ' +\
6217            'name: ' + repr(self.name) + ' ' +\
6218            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6219            'subdomain: ' + repr(self.subdomain) + ' ' +\
6220            'tags: ' + repr(self.tags) + ' ' +\
6221            'url: ' + repr(self.url) + ' ' +\
6222            '>'
6223
6224    def to_dict(self):
6225        return {
6226            'bind_interface': self.bind_interface,
6227            'default_path': self.default_path,
6228            'egress_filter': self.egress_filter,
6229            'headers_blacklist': self.headers_blacklist,
6230            'healthcheck_path': self.healthcheck_path,
6231            'healthy': self.healthy,
6232            'id': self.id,
6233            'name': self.name,
6234            'secret_store_id': self.secret_store_id,
6235            'subdomain': self.subdomain,
6236            'tags': self.tags,
6237            'url': self.url,
6238        }
6239
6240    @classmethod
6241    def from_dict(cls, d):
6242        return cls(
6243            bind_interface=d.get('bind_interface'),
6244            default_path=d.get('default_path'),
6245            egress_filter=d.get('egress_filter'),
6246            headers_blacklist=d.get('headers_blacklist'),
6247            healthcheck_path=d.get('healthcheck_path'),
6248            healthy=d.get('healthy'),
6249            id=d.get('id'),
6250            name=d.get('name'),
6251            secret_store_id=d.get('secret_store_id'),
6252            subdomain=d.get('subdomain'),
6253            tags=d.get('tags'),
6254            url=d.get('url'),
6255        )
HTTPNoAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
6144    def __init__(
6145        self,
6146        bind_interface=None,
6147        default_path=None,
6148        egress_filter=None,
6149        headers_blacklist=None,
6150        healthcheck_path=None,
6151        healthy=None,
6152        id=None,
6153        name=None,
6154        secret_store_id=None,
6155        subdomain=None,
6156        tags=None,
6157        url=None,
6158    ):
6159        self.bind_interface = bind_interface if bind_interface is not None else ''
6160        '''
6161         Bind interface
6162        '''
6163        self.default_path = default_path if default_path is not None else ''
6164        '''
6165
6166        '''
6167        self.egress_filter = egress_filter if egress_filter is not None else ''
6168        '''
6169         A filter applied to the routing logic to pin datasource to nodes.
6170        '''
6171        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6172        '''
6173
6174        '''
6175        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6176        '''
6177
6178        '''
6179        self.healthy = healthy if healthy is not None else False
6180        '''
6181         True if the datasource is reachable and the credentials are valid.
6182        '''
6183        self.id = id if id is not None else ''
6184        '''
6185         Unique identifier of the Resource.
6186        '''
6187        self.name = name if name is not None else ''
6188        '''
6189         Unique human-readable name of the Resource.
6190        '''
6191        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6192        '''
6193         ID of the secret store containing credentials for this resource, if any.
6194        '''
6195        self.subdomain = subdomain if subdomain is not None else ''
6196        '''
6197
6198        '''
6199        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6200        '''
6201         Tags is a map of key, value pairs.
6202        '''
6203        self.url = url if url is not None else ''
6204        '''
6205
6206        '''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
6224    def to_dict(self):
6225        return {
6226            'bind_interface': self.bind_interface,
6227            'default_path': self.default_path,
6228            'egress_filter': self.egress_filter,
6229            'headers_blacklist': self.headers_blacklist,
6230            'healthcheck_path': self.healthcheck_path,
6231            'healthy': self.healthy,
6232            'id': self.id,
6233            'name': self.name,
6234            'secret_store_id': self.secret_store_id,
6235            'subdomain': self.subdomain,
6236            'tags': self.tags,
6237            'url': self.url,
6238        }
@classmethod
def from_dict(cls, d)
6240    @classmethod
6241    def from_dict(cls, d):
6242        return cls(
6243            bind_interface=d.get('bind_interface'),
6244            default_path=d.get('default_path'),
6245            egress_filter=d.get('egress_filter'),
6246            headers_blacklist=d.get('headers_blacklist'),
6247            healthcheck_path=d.get('healthcheck_path'),
6248            healthy=d.get('healthy'),
6249            id=d.get('id'),
6250            name=d.get('name'),
6251            secret_store_id=d.get('secret_store_id'),
6252            subdomain=d.get('subdomain'),
6253            tags=d.get('tags'),
6254            url=d.get('url'),
6255        )
class Kubernetes:
6258class Kubernetes:
6259    '''
6260
6261    '''
6262    __slots__ = [
6263        'bind_interface',
6264        'certificate_authority',
6265        'client_certificate',
6266        'client_key',
6267        'egress_filter',
6268        'healthcheck_namespace',
6269        'healthy',
6270        'hostname',
6271        'id',
6272        'name',
6273        'port',
6274        'port_override',
6275        'remote_identity_group_id',
6276        'remote_identity_healthcheck_username',
6277        'secret_store_id',
6278        'tags',
6279    ]
6280
6281    def __init__(
6282        self,
6283        bind_interface=None,
6284        certificate_authority=None,
6285        client_certificate=None,
6286        client_key=None,
6287        egress_filter=None,
6288        healthcheck_namespace=None,
6289        healthy=None,
6290        hostname=None,
6291        id=None,
6292        name=None,
6293        port=None,
6294        port_override=None,
6295        remote_identity_group_id=None,
6296        remote_identity_healthcheck_username=None,
6297        secret_store_id=None,
6298        tags=None,
6299    ):
6300        self.bind_interface = bind_interface if bind_interface is not None else ''
6301        '''
6302         Bind interface
6303        '''
6304        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6305        '''
6306
6307        '''
6308        self.client_certificate = client_certificate if client_certificate is not None else ''
6309        '''
6310
6311        '''
6312        self.client_key = client_key if client_key is not None else ''
6313        '''
6314
6315        '''
6316        self.egress_filter = egress_filter if egress_filter is not None else ''
6317        '''
6318         A filter applied to the routing logic to pin datasource to nodes.
6319        '''
6320        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6321        '''
6322         The path used to check the health of your connection.  Defaults to `default`.
6323        '''
6324        self.healthy = healthy if healthy is not None else False
6325        '''
6326         True if the datasource is reachable and the credentials are valid.
6327        '''
6328        self.hostname = hostname if hostname is not None else ''
6329        '''
6330
6331        '''
6332        self.id = id if id is not None else ''
6333        '''
6334         Unique identifier of the Resource.
6335        '''
6336        self.name = name if name is not None else ''
6337        '''
6338         Unique human-readable name of the Resource.
6339        '''
6340        self.port = port if port is not None else 0
6341        '''
6342
6343        '''
6344        self.port_override = port_override if port_override is not None else 0
6345        '''
6346
6347        '''
6348        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6349        '''
6350
6351        '''
6352        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6353        '''
6354
6355        '''
6356        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6357        '''
6358         ID of the secret store containing credentials for this resource, if any.
6359        '''
6360        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6361        '''
6362         Tags is a map of key, value pairs.
6363        '''
6364
6365    def __repr__(self):
6366        return '<sdm.Kubernetes ' + \
6367            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6368            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6369            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6370            'client_key: ' + repr(self.client_key) + ' ' +\
6371            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6372            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6373            'healthy: ' + repr(self.healthy) + ' ' +\
6374            'hostname: ' + repr(self.hostname) + ' ' +\
6375            'id: ' + repr(self.id) + ' ' +\
6376            'name: ' + repr(self.name) + ' ' +\
6377            'port: ' + repr(self.port) + ' ' +\
6378            'port_override: ' + repr(self.port_override) + ' ' +\
6379            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
6380            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
6381            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6382            'tags: ' + repr(self.tags) + ' ' +\
6383            '>'
6384
6385    def to_dict(self):
6386        return {
6387            'bind_interface': self.bind_interface,
6388            'certificate_authority': self.certificate_authority,
6389            'client_certificate': self.client_certificate,
6390            'client_key': self.client_key,
6391            'egress_filter': self.egress_filter,
6392            'healthcheck_namespace': self.healthcheck_namespace,
6393            'healthy': self.healthy,
6394            'hostname': self.hostname,
6395            'id': self.id,
6396            'name': self.name,
6397            'port': self.port,
6398            'port_override': self.port_override,
6399            'remote_identity_group_id': self.remote_identity_group_id,
6400            'remote_identity_healthcheck_username':
6401            self.remote_identity_healthcheck_username,
6402            'secret_store_id': self.secret_store_id,
6403            'tags': self.tags,
6404        }
6405
6406    @classmethod
6407    def from_dict(cls, d):
6408        return cls(
6409            bind_interface=d.get('bind_interface'),
6410            certificate_authority=d.get('certificate_authority'),
6411            client_certificate=d.get('client_certificate'),
6412            client_key=d.get('client_key'),
6413            egress_filter=d.get('egress_filter'),
6414            healthcheck_namespace=d.get('healthcheck_namespace'),
6415            healthy=d.get('healthy'),
6416            hostname=d.get('hostname'),
6417            id=d.get('id'),
6418            name=d.get('name'),
6419            port=d.get('port'),
6420            port_override=d.get('port_override'),
6421            remote_identity_group_id=d.get('remote_identity_group_id'),
6422            remote_identity_healthcheck_username=d.get(
6423                'remote_identity_healthcheck_username'),
6424            secret_store_id=d.get('secret_store_id'),
6425            tags=d.get('tags'),
6426        )
Kubernetes( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
6281    def __init__(
6282        self,
6283        bind_interface=None,
6284        certificate_authority=None,
6285        client_certificate=None,
6286        client_key=None,
6287        egress_filter=None,
6288        healthcheck_namespace=None,
6289        healthy=None,
6290        hostname=None,
6291        id=None,
6292        name=None,
6293        port=None,
6294        port_override=None,
6295        remote_identity_group_id=None,
6296        remote_identity_healthcheck_username=None,
6297        secret_store_id=None,
6298        tags=None,
6299    ):
6300        self.bind_interface = bind_interface if bind_interface is not None else ''
6301        '''
6302         Bind interface
6303        '''
6304        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6305        '''
6306
6307        '''
6308        self.client_certificate = client_certificate if client_certificate is not None else ''
6309        '''
6310
6311        '''
6312        self.client_key = client_key if client_key is not None else ''
6313        '''
6314
6315        '''
6316        self.egress_filter = egress_filter if egress_filter is not None else ''
6317        '''
6318         A filter applied to the routing logic to pin datasource to nodes.
6319        '''
6320        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6321        '''
6322         The path used to check the health of your connection.  Defaults to `default`.
6323        '''
6324        self.healthy = healthy if healthy is not None else False
6325        '''
6326         True if the datasource is reachable and the credentials are valid.
6327        '''
6328        self.hostname = hostname if hostname is not None else ''
6329        '''
6330
6331        '''
6332        self.id = id if id is not None else ''
6333        '''
6334         Unique identifier of the Resource.
6335        '''
6336        self.name = name if name is not None else ''
6337        '''
6338         Unique human-readable name of the Resource.
6339        '''
6340        self.port = port if port is not None else 0
6341        '''
6342
6343        '''
6344        self.port_override = port_override if port_override is not None else 0
6345        '''
6346
6347        '''
6348        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6349        '''
6350
6351        '''
6352        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6353        '''
6354
6355        '''
6356        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6357        '''
6358         ID of the secret store containing credentials for this resource, if any.
6359        '''
6360        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6361        '''
6362         Tags is a map of key, value pairs.
6363        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6385    def to_dict(self):
6386        return {
6387            'bind_interface': self.bind_interface,
6388            'certificate_authority': self.certificate_authority,
6389            'client_certificate': self.client_certificate,
6390            'client_key': self.client_key,
6391            'egress_filter': self.egress_filter,
6392            'healthcheck_namespace': self.healthcheck_namespace,
6393            'healthy': self.healthy,
6394            'hostname': self.hostname,
6395            'id': self.id,
6396            'name': self.name,
6397            'port': self.port,
6398            'port_override': self.port_override,
6399            'remote_identity_group_id': self.remote_identity_group_id,
6400            'remote_identity_healthcheck_username':
6401            self.remote_identity_healthcheck_username,
6402            'secret_store_id': self.secret_store_id,
6403            'tags': self.tags,
6404        }
@classmethod
def from_dict(cls, d)
6406    @classmethod
6407    def from_dict(cls, d):
6408        return cls(
6409            bind_interface=d.get('bind_interface'),
6410            certificate_authority=d.get('certificate_authority'),
6411            client_certificate=d.get('client_certificate'),
6412            client_key=d.get('client_key'),
6413            egress_filter=d.get('egress_filter'),
6414            healthcheck_namespace=d.get('healthcheck_namespace'),
6415            healthy=d.get('healthy'),
6416            hostname=d.get('hostname'),
6417            id=d.get('id'),
6418            name=d.get('name'),
6419            port=d.get('port'),
6420            port_override=d.get('port_override'),
6421            remote_identity_group_id=d.get('remote_identity_group_id'),
6422            remote_identity_healthcheck_username=d.get(
6423                'remote_identity_healthcheck_username'),
6424            secret_store_id=d.get('secret_store_id'),
6425            tags=d.get('tags'),
6426        )
class KubernetesBasicAuth:
6429class KubernetesBasicAuth:
6430    '''
6431
6432    '''
6433    __slots__ = [
6434        'bind_interface',
6435        'egress_filter',
6436        'healthcheck_namespace',
6437        'healthy',
6438        'hostname',
6439        'id',
6440        'name',
6441        'password',
6442        'port',
6443        'port_override',
6444        'secret_store_id',
6445        'tags',
6446        'username',
6447    ]
6448
6449    def __init__(
6450        self,
6451        bind_interface=None,
6452        egress_filter=None,
6453        healthcheck_namespace=None,
6454        healthy=None,
6455        hostname=None,
6456        id=None,
6457        name=None,
6458        password=None,
6459        port=None,
6460        port_override=None,
6461        secret_store_id=None,
6462        tags=None,
6463        username=None,
6464    ):
6465        self.bind_interface = bind_interface if bind_interface is not None else ''
6466        '''
6467         Bind interface
6468        '''
6469        self.egress_filter = egress_filter if egress_filter is not None else ''
6470        '''
6471         A filter applied to the routing logic to pin datasource to nodes.
6472        '''
6473        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6474        '''
6475         The path used to check the health of your connection.  Defaults to `default`.
6476        '''
6477        self.healthy = healthy if healthy is not None else False
6478        '''
6479         True if the datasource is reachable and the credentials are valid.
6480        '''
6481        self.hostname = hostname if hostname is not None else ''
6482        '''
6483
6484        '''
6485        self.id = id if id is not None else ''
6486        '''
6487         Unique identifier of the Resource.
6488        '''
6489        self.name = name if name is not None else ''
6490        '''
6491         Unique human-readable name of the Resource.
6492        '''
6493        self.password = password if password is not None else ''
6494        '''
6495
6496        '''
6497        self.port = port if port is not None else 0
6498        '''
6499
6500        '''
6501        self.port_override = port_override if port_override is not None else 0
6502        '''
6503
6504        '''
6505        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6506        '''
6507         ID of the secret store containing credentials for this resource, if any.
6508        '''
6509        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6510        '''
6511         Tags is a map of key, value pairs.
6512        '''
6513        self.username = username if username is not None else ''
6514        '''
6515
6516        '''
6517
6518    def __repr__(self):
6519        return '<sdm.KubernetesBasicAuth ' + \
6520            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6521            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6522            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6523            'healthy: ' + repr(self.healthy) + ' ' +\
6524            'hostname: ' + repr(self.hostname) + ' ' +\
6525            'id: ' + repr(self.id) + ' ' +\
6526            'name: ' + repr(self.name) + ' ' +\
6527            'password: ' + repr(self.password) + ' ' +\
6528            'port: ' + repr(self.port) + ' ' +\
6529            'port_override: ' + repr(self.port_override) + ' ' +\
6530            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6531            'tags: ' + repr(self.tags) + ' ' +\
6532            'username: ' + repr(self.username) + ' ' +\
6533            '>'
6534
6535    def to_dict(self):
6536        return {
6537            'bind_interface': self.bind_interface,
6538            'egress_filter': self.egress_filter,
6539            'healthcheck_namespace': self.healthcheck_namespace,
6540            'healthy': self.healthy,
6541            'hostname': self.hostname,
6542            'id': self.id,
6543            'name': self.name,
6544            'password': self.password,
6545            'port': self.port,
6546            'port_override': self.port_override,
6547            'secret_store_id': self.secret_store_id,
6548            'tags': self.tags,
6549            'username': self.username,
6550        }
6551
6552    @classmethod
6553    def from_dict(cls, d):
6554        return cls(
6555            bind_interface=d.get('bind_interface'),
6556            egress_filter=d.get('egress_filter'),
6557            healthcheck_namespace=d.get('healthcheck_namespace'),
6558            healthy=d.get('healthy'),
6559            hostname=d.get('hostname'),
6560            id=d.get('id'),
6561            name=d.get('name'),
6562            password=d.get('password'),
6563            port=d.get('port'),
6564            port_override=d.get('port_override'),
6565            secret_store_id=d.get('secret_store_id'),
6566            tags=d.get('tags'),
6567            username=d.get('username'),
6568        )
KubernetesBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
6449    def __init__(
6450        self,
6451        bind_interface=None,
6452        egress_filter=None,
6453        healthcheck_namespace=None,
6454        healthy=None,
6455        hostname=None,
6456        id=None,
6457        name=None,
6458        password=None,
6459        port=None,
6460        port_override=None,
6461        secret_store_id=None,
6462        tags=None,
6463        username=None,
6464    ):
6465        self.bind_interface = bind_interface if bind_interface is not None else ''
6466        '''
6467         Bind interface
6468        '''
6469        self.egress_filter = egress_filter if egress_filter is not None else ''
6470        '''
6471         A filter applied to the routing logic to pin datasource to nodes.
6472        '''
6473        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6474        '''
6475         The path used to check the health of your connection.  Defaults to `default`.
6476        '''
6477        self.healthy = healthy if healthy is not None else False
6478        '''
6479         True if the datasource is reachable and the credentials are valid.
6480        '''
6481        self.hostname = hostname if hostname is not None else ''
6482        '''
6483
6484        '''
6485        self.id = id if id is not None else ''
6486        '''
6487         Unique identifier of the Resource.
6488        '''
6489        self.name = name if name is not None else ''
6490        '''
6491         Unique human-readable name of the Resource.
6492        '''
6493        self.password = password if password is not None else ''
6494        '''
6495
6496        '''
6497        self.port = port if port is not None else 0
6498        '''
6499
6500        '''
6501        self.port_override = port_override if port_override is not None else 0
6502        '''
6503
6504        '''
6505        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6506        '''
6507         ID of the secret store containing credentials for this resource, if any.
6508        '''
6509        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6510        '''
6511         Tags is a map of key, value pairs.
6512        '''
6513        self.username = username if username is not None else ''
6514        '''
6515
6516        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6535    def to_dict(self):
6536        return {
6537            'bind_interface': self.bind_interface,
6538            'egress_filter': self.egress_filter,
6539            'healthcheck_namespace': self.healthcheck_namespace,
6540            'healthy': self.healthy,
6541            'hostname': self.hostname,
6542            'id': self.id,
6543            'name': self.name,
6544            'password': self.password,
6545            'port': self.port,
6546            'port_override': self.port_override,
6547            'secret_store_id': self.secret_store_id,
6548            'tags': self.tags,
6549            'username': self.username,
6550        }
@classmethod
def from_dict(cls, d)
6552    @classmethod
6553    def from_dict(cls, d):
6554        return cls(
6555            bind_interface=d.get('bind_interface'),
6556            egress_filter=d.get('egress_filter'),
6557            healthcheck_namespace=d.get('healthcheck_namespace'),
6558            healthy=d.get('healthy'),
6559            hostname=d.get('hostname'),
6560            id=d.get('id'),
6561            name=d.get('name'),
6562            password=d.get('password'),
6563            port=d.get('port'),
6564            port_override=d.get('port_override'),
6565            secret_store_id=d.get('secret_store_id'),
6566            tags=d.get('tags'),
6567            username=d.get('username'),
6568        )
class KubernetesServiceAccount:
6571class KubernetesServiceAccount:
6572    '''
6573
6574    '''
6575    __slots__ = [
6576        'bind_interface',
6577        'egress_filter',
6578        'healthcheck_namespace',
6579        'healthy',
6580        'hostname',
6581        'id',
6582        'name',
6583        'port',
6584        'port_override',
6585        'remote_identity_group_id',
6586        'remote_identity_healthcheck_username',
6587        'secret_store_id',
6588        'tags',
6589        'token',
6590    ]
6591
6592    def __init__(
6593        self,
6594        bind_interface=None,
6595        egress_filter=None,
6596        healthcheck_namespace=None,
6597        healthy=None,
6598        hostname=None,
6599        id=None,
6600        name=None,
6601        port=None,
6602        port_override=None,
6603        remote_identity_group_id=None,
6604        remote_identity_healthcheck_username=None,
6605        secret_store_id=None,
6606        tags=None,
6607        token=None,
6608    ):
6609        self.bind_interface = bind_interface if bind_interface is not None else ''
6610        '''
6611         Bind interface
6612        '''
6613        self.egress_filter = egress_filter if egress_filter is not None else ''
6614        '''
6615         A filter applied to the routing logic to pin datasource to nodes.
6616        '''
6617        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6618        '''
6619         The path used to check the health of your connection.  Defaults to `default`.
6620        '''
6621        self.healthy = healthy if healthy is not None else False
6622        '''
6623         True if the datasource is reachable and the credentials are valid.
6624        '''
6625        self.hostname = hostname if hostname is not None else ''
6626        '''
6627
6628        '''
6629        self.id = id if id is not None else ''
6630        '''
6631         Unique identifier of the Resource.
6632        '''
6633        self.name = name if name is not None else ''
6634        '''
6635         Unique human-readable name of the Resource.
6636        '''
6637        self.port = port if port is not None else 0
6638        '''
6639
6640        '''
6641        self.port_override = port_override if port_override is not None else 0
6642        '''
6643
6644        '''
6645        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6646        '''
6647
6648        '''
6649        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6650        '''
6651
6652        '''
6653        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6654        '''
6655         ID of the secret store containing credentials for this resource, if any.
6656        '''
6657        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6658        '''
6659         Tags is a map of key, value pairs.
6660        '''
6661        self.token = token if token is not None else ''
6662        '''
6663
6664        '''
6665
6666    def __repr__(self):
6667        return '<sdm.KubernetesServiceAccount ' + \
6668            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6669            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6670            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6671            'healthy: ' + repr(self.healthy) + ' ' +\
6672            'hostname: ' + repr(self.hostname) + ' ' +\
6673            'id: ' + repr(self.id) + ' ' +\
6674            'name: ' + repr(self.name) + ' ' +\
6675            'port: ' + repr(self.port) + ' ' +\
6676            'port_override: ' + repr(self.port_override) + ' ' +\
6677            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
6678            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
6679            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6680            'tags: ' + repr(self.tags) + ' ' +\
6681            'token: ' + repr(self.token) + ' ' +\
6682            '>'
6683
6684    def to_dict(self):
6685        return {
6686            'bind_interface': self.bind_interface,
6687            'egress_filter': self.egress_filter,
6688            'healthcheck_namespace': self.healthcheck_namespace,
6689            'healthy': self.healthy,
6690            'hostname': self.hostname,
6691            'id': self.id,
6692            'name': self.name,
6693            'port': self.port,
6694            'port_override': self.port_override,
6695            'remote_identity_group_id': self.remote_identity_group_id,
6696            'remote_identity_healthcheck_username':
6697            self.remote_identity_healthcheck_username,
6698            'secret_store_id': self.secret_store_id,
6699            'tags': self.tags,
6700            'token': self.token,
6701        }
6702
6703    @classmethod
6704    def from_dict(cls, d):
6705        return cls(
6706            bind_interface=d.get('bind_interface'),
6707            egress_filter=d.get('egress_filter'),
6708            healthcheck_namespace=d.get('healthcheck_namespace'),
6709            healthy=d.get('healthy'),
6710            hostname=d.get('hostname'),
6711            id=d.get('id'),
6712            name=d.get('name'),
6713            port=d.get('port'),
6714            port_override=d.get('port_override'),
6715            remote_identity_group_id=d.get('remote_identity_group_id'),
6716            remote_identity_healthcheck_username=d.get(
6717                'remote_identity_healthcheck_username'),
6718            secret_store_id=d.get('secret_store_id'),
6719            tags=d.get('tags'),
6720            token=d.get('token'),
6721        )
KubernetesServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
6592    def __init__(
6593        self,
6594        bind_interface=None,
6595        egress_filter=None,
6596        healthcheck_namespace=None,
6597        healthy=None,
6598        hostname=None,
6599        id=None,
6600        name=None,
6601        port=None,
6602        port_override=None,
6603        remote_identity_group_id=None,
6604        remote_identity_healthcheck_username=None,
6605        secret_store_id=None,
6606        tags=None,
6607        token=None,
6608    ):
6609        self.bind_interface = bind_interface if bind_interface is not None else ''
6610        '''
6611         Bind interface
6612        '''
6613        self.egress_filter = egress_filter if egress_filter is not None else ''
6614        '''
6615         A filter applied to the routing logic to pin datasource to nodes.
6616        '''
6617        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6618        '''
6619         The path used to check the health of your connection.  Defaults to `default`.
6620        '''
6621        self.healthy = healthy if healthy is not None else False
6622        '''
6623         True if the datasource is reachable and the credentials are valid.
6624        '''
6625        self.hostname = hostname if hostname is not None else ''
6626        '''
6627
6628        '''
6629        self.id = id if id is not None else ''
6630        '''
6631         Unique identifier of the Resource.
6632        '''
6633        self.name = name if name is not None else ''
6634        '''
6635         Unique human-readable name of the Resource.
6636        '''
6637        self.port = port if port is not None else 0
6638        '''
6639
6640        '''
6641        self.port_override = port_override if port_override is not None else 0
6642        '''
6643
6644        '''
6645        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6646        '''
6647
6648        '''
6649        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6650        '''
6651
6652        '''
6653        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6654        '''
6655         ID of the secret store containing credentials for this resource, if any.
6656        '''
6657        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6658        '''
6659         Tags is a map of key, value pairs.
6660        '''
6661        self.token = token if token is not None else ''
6662        '''
6663
6664        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6684    def to_dict(self):
6685        return {
6686            'bind_interface': self.bind_interface,
6687            'egress_filter': self.egress_filter,
6688            'healthcheck_namespace': self.healthcheck_namespace,
6689            'healthy': self.healthy,
6690            'hostname': self.hostname,
6691            'id': self.id,
6692            'name': self.name,
6693            'port': self.port,
6694            'port_override': self.port_override,
6695            'remote_identity_group_id': self.remote_identity_group_id,
6696            'remote_identity_healthcheck_username':
6697            self.remote_identity_healthcheck_username,
6698            'secret_store_id': self.secret_store_id,
6699            'tags': self.tags,
6700            'token': self.token,
6701        }
@classmethod
def from_dict(cls, d)
6703    @classmethod
6704    def from_dict(cls, d):
6705        return cls(
6706            bind_interface=d.get('bind_interface'),
6707            egress_filter=d.get('egress_filter'),
6708            healthcheck_namespace=d.get('healthcheck_namespace'),
6709            healthy=d.get('healthy'),
6710            hostname=d.get('hostname'),
6711            id=d.get('id'),
6712            name=d.get('name'),
6713            port=d.get('port'),
6714            port_override=d.get('port_override'),
6715            remote_identity_group_id=d.get('remote_identity_group_id'),
6716            remote_identity_healthcheck_username=d.get(
6717                'remote_identity_healthcheck_username'),
6718            secret_store_id=d.get('secret_store_id'),
6719            tags=d.get('tags'),
6720            token=d.get('token'),
6721        )
class KubernetesServiceAccountUserImpersonation:
6724class KubernetesServiceAccountUserImpersonation:
6725    '''
6726
6727    '''
6728    __slots__ = [
6729        'bind_interface',
6730        'egress_filter',
6731        'healthcheck_namespace',
6732        'healthy',
6733        'hostname',
6734        'id',
6735        'name',
6736        'port',
6737        'port_override',
6738        'secret_store_id',
6739        'tags',
6740        'token',
6741    ]
6742
6743    def __init__(
6744        self,
6745        bind_interface=None,
6746        egress_filter=None,
6747        healthcheck_namespace=None,
6748        healthy=None,
6749        hostname=None,
6750        id=None,
6751        name=None,
6752        port=None,
6753        port_override=None,
6754        secret_store_id=None,
6755        tags=None,
6756        token=None,
6757    ):
6758        self.bind_interface = bind_interface if bind_interface is not None else ''
6759        '''
6760         Bind interface
6761        '''
6762        self.egress_filter = egress_filter if egress_filter is not None else ''
6763        '''
6764         A filter applied to the routing logic to pin datasource to nodes.
6765        '''
6766        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6767        '''
6768         The path used to check the health of your connection.  Defaults to `default`.
6769        '''
6770        self.healthy = healthy if healthy is not None else False
6771        '''
6772         True if the datasource is reachable and the credentials are valid.
6773        '''
6774        self.hostname = hostname if hostname is not None else ''
6775        '''
6776
6777        '''
6778        self.id = id if id is not None else ''
6779        '''
6780         Unique identifier of the Resource.
6781        '''
6782        self.name = name if name is not None else ''
6783        '''
6784         Unique human-readable name of the Resource.
6785        '''
6786        self.port = port if port is not None else 0
6787        '''
6788
6789        '''
6790        self.port_override = port_override if port_override is not None else 0
6791        '''
6792
6793        '''
6794        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6795        '''
6796         ID of the secret store containing credentials for this resource, if any.
6797        '''
6798        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6799        '''
6800         Tags is a map of key, value pairs.
6801        '''
6802        self.token = token if token is not None else ''
6803        '''
6804
6805        '''
6806
6807    def __repr__(self):
6808        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
6809            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6810            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6811            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6812            'healthy: ' + repr(self.healthy) + ' ' +\
6813            'hostname: ' + repr(self.hostname) + ' ' +\
6814            'id: ' + repr(self.id) + ' ' +\
6815            'name: ' + repr(self.name) + ' ' +\
6816            'port: ' + repr(self.port) + ' ' +\
6817            'port_override: ' + repr(self.port_override) + ' ' +\
6818            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6819            'tags: ' + repr(self.tags) + ' ' +\
6820            'token: ' + repr(self.token) + ' ' +\
6821            '>'
6822
6823    def to_dict(self):
6824        return {
6825            'bind_interface': self.bind_interface,
6826            'egress_filter': self.egress_filter,
6827            'healthcheck_namespace': self.healthcheck_namespace,
6828            'healthy': self.healthy,
6829            'hostname': self.hostname,
6830            'id': self.id,
6831            'name': self.name,
6832            'port': self.port,
6833            'port_override': self.port_override,
6834            'secret_store_id': self.secret_store_id,
6835            'tags': self.tags,
6836            'token': self.token,
6837        }
6838
6839    @classmethod
6840    def from_dict(cls, d):
6841        return cls(
6842            bind_interface=d.get('bind_interface'),
6843            egress_filter=d.get('egress_filter'),
6844            healthcheck_namespace=d.get('healthcheck_namespace'),
6845            healthy=d.get('healthy'),
6846            hostname=d.get('hostname'),
6847            id=d.get('id'),
6848            name=d.get('name'),
6849            port=d.get('port'),
6850            port_override=d.get('port_override'),
6851            secret_store_id=d.get('secret_store_id'),
6852            tags=d.get('tags'),
6853            token=d.get('token'),
6854        )
KubernetesServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None, token=None)
6743    def __init__(
6744        self,
6745        bind_interface=None,
6746        egress_filter=None,
6747        healthcheck_namespace=None,
6748        healthy=None,
6749        hostname=None,
6750        id=None,
6751        name=None,
6752        port=None,
6753        port_override=None,
6754        secret_store_id=None,
6755        tags=None,
6756        token=None,
6757    ):
6758        self.bind_interface = bind_interface if bind_interface is not None else ''
6759        '''
6760         Bind interface
6761        '''
6762        self.egress_filter = egress_filter if egress_filter is not None else ''
6763        '''
6764         A filter applied to the routing logic to pin datasource to nodes.
6765        '''
6766        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6767        '''
6768         The path used to check the health of your connection.  Defaults to `default`.
6769        '''
6770        self.healthy = healthy if healthy is not None else False
6771        '''
6772         True if the datasource is reachable and the credentials are valid.
6773        '''
6774        self.hostname = hostname if hostname is not None else ''
6775        '''
6776
6777        '''
6778        self.id = id if id is not None else ''
6779        '''
6780         Unique identifier of the Resource.
6781        '''
6782        self.name = name if name is not None else ''
6783        '''
6784         Unique human-readable name of the Resource.
6785        '''
6786        self.port = port if port is not None else 0
6787        '''
6788
6789        '''
6790        self.port_override = port_override if port_override is not None else 0
6791        '''
6792
6793        '''
6794        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6795        '''
6796         ID of the secret store containing credentials for this resource, if any.
6797        '''
6798        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6799        '''
6800         Tags is a map of key, value pairs.
6801        '''
6802        self.token = token if token is not None else ''
6803        '''
6804
6805        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6823    def to_dict(self):
6824        return {
6825            'bind_interface': self.bind_interface,
6826            'egress_filter': self.egress_filter,
6827            'healthcheck_namespace': self.healthcheck_namespace,
6828            'healthy': self.healthy,
6829            'hostname': self.hostname,
6830            'id': self.id,
6831            'name': self.name,
6832            'port': self.port,
6833            'port_override': self.port_override,
6834            'secret_store_id': self.secret_store_id,
6835            'tags': self.tags,
6836            'token': self.token,
6837        }
@classmethod
def from_dict(cls, d)
6839    @classmethod
6840    def from_dict(cls, d):
6841        return cls(
6842            bind_interface=d.get('bind_interface'),
6843            egress_filter=d.get('egress_filter'),
6844            healthcheck_namespace=d.get('healthcheck_namespace'),
6845            healthy=d.get('healthy'),
6846            hostname=d.get('hostname'),
6847            id=d.get('id'),
6848            name=d.get('name'),
6849            port=d.get('port'),
6850            port_override=d.get('port_override'),
6851            secret_store_id=d.get('secret_store_id'),
6852            tags=d.get('tags'),
6853            token=d.get('token'),
6854        )
class KubernetesUserImpersonation:
6857class KubernetesUserImpersonation:
6858    '''
6859
6860    '''
6861    __slots__ = [
6862        'bind_interface',
6863        'certificate_authority',
6864        'client_certificate',
6865        'client_key',
6866        'egress_filter',
6867        'healthcheck_namespace',
6868        'healthy',
6869        'hostname',
6870        'id',
6871        'name',
6872        'port',
6873        'port_override',
6874        'secret_store_id',
6875        'tags',
6876    ]
6877
6878    def __init__(
6879        self,
6880        bind_interface=None,
6881        certificate_authority=None,
6882        client_certificate=None,
6883        client_key=None,
6884        egress_filter=None,
6885        healthcheck_namespace=None,
6886        healthy=None,
6887        hostname=None,
6888        id=None,
6889        name=None,
6890        port=None,
6891        port_override=None,
6892        secret_store_id=None,
6893        tags=None,
6894    ):
6895        self.bind_interface = bind_interface if bind_interface is not None else ''
6896        '''
6897         Bind interface
6898        '''
6899        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6900        '''
6901
6902        '''
6903        self.client_certificate = client_certificate if client_certificate is not None else ''
6904        '''
6905
6906        '''
6907        self.client_key = client_key if client_key is not None else ''
6908        '''
6909
6910        '''
6911        self.egress_filter = egress_filter if egress_filter is not None else ''
6912        '''
6913         A filter applied to the routing logic to pin datasource to nodes.
6914        '''
6915        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6916        '''
6917         The path used to check the health of your connection.  Defaults to `default`.
6918        '''
6919        self.healthy = healthy if healthy is not None else False
6920        '''
6921         True if the datasource is reachable and the credentials are valid.
6922        '''
6923        self.hostname = hostname if hostname is not None else ''
6924        '''
6925
6926        '''
6927        self.id = id if id is not None else ''
6928        '''
6929         Unique identifier of the Resource.
6930        '''
6931        self.name = name if name is not None else ''
6932        '''
6933         Unique human-readable name of the Resource.
6934        '''
6935        self.port = port if port is not None else 0
6936        '''
6937
6938        '''
6939        self.port_override = port_override if port_override is not None else 0
6940        '''
6941
6942        '''
6943        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6944        '''
6945         ID of the secret store containing credentials for this resource, if any.
6946        '''
6947        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6948        '''
6949         Tags is a map of key, value pairs.
6950        '''
6951
6952    def __repr__(self):
6953        return '<sdm.KubernetesUserImpersonation ' + \
6954            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6955            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6956            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6957            'client_key: ' + repr(self.client_key) + ' ' +\
6958            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6959            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6960            'healthy: ' + repr(self.healthy) + ' ' +\
6961            'hostname: ' + repr(self.hostname) + ' ' +\
6962            'id: ' + repr(self.id) + ' ' +\
6963            'name: ' + repr(self.name) + ' ' +\
6964            'port: ' + repr(self.port) + ' ' +\
6965            'port_override: ' + repr(self.port_override) + ' ' +\
6966            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6967            'tags: ' + repr(self.tags) + ' ' +\
6968            '>'
6969
6970    def to_dict(self):
6971        return {
6972            'bind_interface': self.bind_interface,
6973            'certificate_authority': self.certificate_authority,
6974            'client_certificate': self.client_certificate,
6975            'client_key': self.client_key,
6976            'egress_filter': self.egress_filter,
6977            'healthcheck_namespace': self.healthcheck_namespace,
6978            'healthy': self.healthy,
6979            'hostname': self.hostname,
6980            'id': self.id,
6981            'name': self.name,
6982            'port': self.port,
6983            'port_override': self.port_override,
6984            'secret_store_id': self.secret_store_id,
6985            'tags': self.tags,
6986        }
6987
6988    @classmethod
6989    def from_dict(cls, d):
6990        return cls(
6991            bind_interface=d.get('bind_interface'),
6992            certificate_authority=d.get('certificate_authority'),
6993            client_certificate=d.get('client_certificate'),
6994            client_key=d.get('client_key'),
6995            egress_filter=d.get('egress_filter'),
6996            healthcheck_namespace=d.get('healthcheck_namespace'),
6997            healthy=d.get('healthy'),
6998            hostname=d.get('hostname'),
6999            id=d.get('id'),
7000            name=d.get('name'),
7001            port=d.get('port'),
7002            port_override=d.get('port_override'),
7003            secret_store_id=d.get('secret_store_id'),
7004            tags=d.get('tags'),
7005        )
KubernetesUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
6878    def __init__(
6879        self,
6880        bind_interface=None,
6881        certificate_authority=None,
6882        client_certificate=None,
6883        client_key=None,
6884        egress_filter=None,
6885        healthcheck_namespace=None,
6886        healthy=None,
6887        hostname=None,
6888        id=None,
6889        name=None,
6890        port=None,
6891        port_override=None,
6892        secret_store_id=None,
6893        tags=None,
6894    ):
6895        self.bind_interface = bind_interface if bind_interface is not None else ''
6896        '''
6897         Bind interface
6898        '''
6899        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6900        '''
6901
6902        '''
6903        self.client_certificate = client_certificate if client_certificate is not None else ''
6904        '''
6905
6906        '''
6907        self.client_key = client_key if client_key is not None else ''
6908        '''
6909
6910        '''
6911        self.egress_filter = egress_filter if egress_filter is not None else ''
6912        '''
6913         A filter applied to the routing logic to pin datasource to nodes.
6914        '''
6915        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6916        '''
6917         The path used to check the health of your connection.  Defaults to `default`.
6918        '''
6919        self.healthy = healthy if healthy is not None else False
6920        '''
6921         True if the datasource is reachable and the credentials are valid.
6922        '''
6923        self.hostname = hostname if hostname is not None else ''
6924        '''
6925
6926        '''
6927        self.id = id if id is not None else ''
6928        '''
6929         Unique identifier of the Resource.
6930        '''
6931        self.name = name if name is not None else ''
6932        '''
6933         Unique human-readable name of the Resource.
6934        '''
6935        self.port = port if port is not None else 0
6936        '''
6937
6938        '''
6939        self.port_override = port_override if port_override is not None else 0
6940        '''
6941
6942        '''
6943        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6944        '''
6945         ID of the secret store containing credentials for this resource, if any.
6946        '''
6947        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6948        '''
6949         Tags is a map of key, value pairs.
6950        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6970    def to_dict(self):
6971        return {
6972            'bind_interface': self.bind_interface,
6973            'certificate_authority': self.certificate_authority,
6974            'client_certificate': self.client_certificate,
6975            'client_key': self.client_key,
6976            'egress_filter': self.egress_filter,
6977            'healthcheck_namespace': self.healthcheck_namespace,
6978            'healthy': self.healthy,
6979            'hostname': self.hostname,
6980            'id': self.id,
6981            'name': self.name,
6982            'port': self.port,
6983            'port_override': self.port_override,
6984            'secret_store_id': self.secret_store_id,
6985            'tags': self.tags,
6986        }
@classmethod
def from_dict(cls, d)
6988    @classmethod
6989    def from_dict(cls, d):
6990        return cls(
6991            bind_interface=d.get('bind_interface'),
6992            certificate_authority=d.get('certificate_authority'),
6993            client_certificate=d.get('client_certificate'),
6994            client_key=d.get('client_key'),
6995            egress_filter=d.get('egress_filter'),
6996            healthcheck_namespace=d.get('healthcheck_namespace'),
6997            healthy=d.get('healthy'),
6998            hostname=d.get('hostname'),
6999            id=d.get('id'),
7000            name=d.get('name'),
7001            port=d.get('port'),
7002            port_override=d.get('port_override'),
7003            secret_store_id=d.get('secret_store_id'),
7004            tags=d.get('tags'),
7005        )
class MTLSMysql:
7008class MTLSMysql:
7009    '''
7010
7011    '''
7012    __slots__ = [
7013        'bind_interface',
7014        'certificate_authority',
7015        'client_certificate',
7016        'client_key',
7017        'database',
7018        'egress_filter',
7019        'healthy',
7020        'hostname',
7021        'id',
7022        'name',
7023        'password',
7024        'port',
7025        'port_override',
7026        'secret_store_id',
7027        'server_name',
7028        'tags',
7029        'username',
7030    ]
7031
7032    def __init__(
7033        self,
7034        bind_interface=None,
7035        certificate_authority=None,
7036        client_certificate=None,
7037        client_key=None,
7038        database=None,
7039        egress_filter=None,
7040        healthy=None,
7041        hostname=None,
7042        id=None,
7043        name=None,
7044        password=None,
7045        port=None,
7046        port_override=None,
7047        secret_store_id=None,
7048        server_name=None,
7049        tags=None,
7050        username=None,
7051    ):
7052        self.bind_interface = bind_interface if bind_interface is not None else ''
7053        '''
7054         Bind interface
7055        '''
7056        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
7057        '''
7058
7059        '''
7060        self.client_certificate = client_certificate if client_certificate is not None else ''
7061        '''
7062
7063        '''
7064        self.client_key = client_key if client_key is not None else ''
7065        '''
7066
7067        '''
7068        self.database = database if database is not None else ''
7069        '''
7070
7071        '''
7072        self.egress_filter = egress_filter if egress_filter is not None else ''
7073        '''
7074         A filter applied to the routing logic to pin datasource to nodes.
7075        '''
7076        self.healthy = healthy if healthy is not None else False
7077        '''
7078         True if the datasource is reachable and the credentials are valid.
7079        '''
7080        self.hostname = hostname if hostname is not None else ''
7081        '''
7082
7083        '''
7084        self.id = id if id is not None else ''
7085        '''
7086         Unique identifier of the Resource.
7087        '''
7088        self.name = name if name is not None else ''
7089        '''
7090         Unique human-readable name of the Resource.
7091        '''
7092        self.password = password if password is not None else ''
7093        '''
7094
7095        '''
7096        self.port = port if port is not None else 0
7097        '''
7098
7099        '''
7100        self.port_override = port_override if port_override is not None else 0
7101        '''
7102
7103        '''
7104        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7105        '''
7106         ID of the secret store containing credentials for this resource, if any.
7107        '''
7108        self.server_name = server_name if server_name is not None else ''
7109        '''
7110
7111        '''
7112        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7113        '''
7114         Tags is a map of key, value pairs.
7115        '''
7116        self.username = username if username is not None else ''
7117        '''
7118
7119        '''
7120
7121    def __repr__(self):
7122        return '<sdm.MTLSMysql ' + \
7123            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7124            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
7125            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
7126            'client_key: ' + repr(self.client_key) + ' ' +\
7127            'database: ' + repr(self.database) + ' ' +\
7128            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7129            'healthy: ' + repr(self.healthy) + ' ' +\
7130            'hostname: ' + repr(self.hostname) + ' ' +\
7131            'id: ' + repr(self.id) + ' ' +\
7132            'name: ' + repr(self.name) + ' ' +\
7133            'password: ' + repr(self.password) + ' ' +\
7134            'port: ' + repr(self.port) + ' ' +\
7135            'port_override: ' + repr(self.port_override) + ' ' +\
7136            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7137            'server_name: ' + repr(self.server_name) + ' ' +\
7138            'tags: ' + repr(self.tags) + ' ' +\
7139            'username: ' + repr(self.username) + ' ' +\
7140            '>'
7141
7142    def to_dict(self):
7143        return {
7144            'bind_interface': self.bind_interface,
7145            'certificate_authority': self.certificate_authority,
7146            'client_certificate': self.client_certificate,
7147            'client_key': self.client_key,
7148            'database': self.database,
7149            'egress_filter': self.egress_filter,
7150            'healthy': self.healthy,
7151            'hostname': self.hostname,
7152            'id': self.id,
7153            'name': self.name,
7154            'password': self.password,
7155            'port': self.port,
7156            'port_override': self.port_override,
7157            'secret_store_id': self.secret_store_id,
7158            'server_name': self.server_name,
7159            'tags': self.tags,
7160            'username': self.username,
7161        }
7162
7163    @classmethod
7164    def from_dict(cls, d):
7165        return cls(
7166            bind_interface=d.get('bind_interface'),
7167            certificate_authority=d.get('certificate_authority'),
7168            client_certificate=d.get('client_certificate'),
7169            client_key=d.get('client_key'),
7170            database=d.get('database'),
7171            egress_filter=d.get('egress_filter'),
7172            healthy=d.get('healthy'),
7173            hostname=d.get('hostname'),
7174            id=d.get('id'),
7175            name=d.get('name'),
7176            password=d.get('password'),
7177            port=d.get('port'),
7178            port_override=d.get('port_override'),
7179            secret_store_id=d.get('secret_store_id'),
7180            server_name=d.get('server_name'),
7181            tags=d.get('tags'),
7182            username=d.get('username'),
7183        )
MTLSMysql( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
7032    def __init__(
7033        self,
7034        bind_interface=None,
7035        certificate_authority=None,
7036        client_certificate=None,
7037        client_key=None,
7038        database=None,
7039        egress_filter=None,
7040        healthy=None,
7041        hostname=None,
7042        id=None,
7043        name=None,
7044        password=None,
7045        port=None,
7046        port_override=None,
7047        secret_store_id=None,
7048        server_name=None,
7049        tags=None,
7050        username=None,
7051    ):
7052        self.bind_interface = bind_interface if bind_interface is not None else ''
7053        '''
7054         Bind interface
7055        '''
7056        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
7057        '''
7058
7059        '''
7060        self.client_certificate = client_certificate if client_certificate is not None else ''
7061        '''
7062
7063        '''
7064        self.client_key = client_key if client_key is not None else ''
7065        '''
7066
7067        '''
7068        self.database = database if database is not None else ''
7069        '''
7070
7071        '''
7072        self.egress_filter = egress_filter if egress_filter is not None else ''
7073        '''
7074         A filter applied to the routing logic to pin datasource to nodes.
7075        '''
7076        self.healthy = healthy if healthy is not None else False
7077        '''
7078         True if the datasource is reachable and the credentials are valid.
7079        '''
7080        self.hostname = hostname if hostname is not None else ''
7081        '''
7082
7083        '''
7084        self.id = id if id is not None else ''
7085        '''
7086         Unique identifier of the Resource.
7087        '''
7088        self.name = name if name is not None else ''
7089        '''
7090         Unique human-readable name of the Resource.
7091        '''
7092        self.password = password if password is not None else ''
7093        '''
7094
7095        '''
7096        self.port = port if port is not None else 0
7097        '''
7098
7099        '''
7100        self.port_override = port_override if port_override is not None else 0
7101        '''
7102
7103        '''
7104        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7105        '''
7106         ID of the secret store containing credentials for this resource, if any.
7107        '''
7108        self.server_name = server_name if server_name is not None else ''
7109        '''
7110
7111        '''
7112        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7113        '''
7114         Tags is a map of key, value pairs.
7115        '''
7116        self.username = username if username is not None else ''
7117        '''
7118
7119        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7142    def to_dict(self):
7143        return {
7144            'bind_interface': self.bind_interface,
7145            'certificate_authority': self.certificate_authority,
7146            'client_certificate': self.client_certificate,
7147            'client_key': self.client_key,
7148            'database': self.database,
7149            'egress_filter': self.egress_filter,
7150            'healthy': self.healthy,
7151            'hostname': self.hostname,
7152            'id': self.id,
7153            'name': self.name,
7154            'password': self.password,
7155            'port': self.port,
7156            'port_override': self.port_override,
7157            'secret_store_id': self.secret_store_id,
7158            'server_name': self.server_name,
7159            'tags': self.tags,
7160            'username': self.username,
7161        }
@classmethod
def from_dict(cls, d)
7163    @classmethod
7164    def from_dict(cls, d):
7165        return cls(
7166            bind_interface=d.get('bind_interface'),
7167            certificate_authority=d.get('certificate_authority'),
7168            client_certificate=d.get('client_certificate'),
7169            client_key=d.get('client_key'),
7170            database=d.get('database'),
7171            egress_filter=d.get('egress_filter'),
7172            healthy=d.get('healthy'),
7173            hostname=d.get('hostname'),
7174            id=d.get('id'),
7175            name=d.get('name'),
7176            password=d.get('password'),
7177            port=d.get('port'),
7178            port_override=d.get('port_override'),
7179            secret_store_id=d.get('secret_store_id'),
7180            server_name=d.get('server_name'),
7181            tags=d.get('tags'),
7182            username=d.get('username'),
7183        )
class MTLSPostgres:
7186class MTLSPostgres:
7187    '''
7188
7189    '''
7190    __slots__ = [
7191        'bind_interface',
7192        'certificate_authority',
7193        'client_certificate',
7194        'client_key',
7195        'database',
7196        'egress_filter',
7197        'healthy',
7198        'hostname',
7199        'id',
7200        'name',
7201        'override_database',
7202        'password',
7203        'port',
7204        'port_override',
7205        'secret_store_id',
7206        'server_name',
7207        'tags',
7208        'username',
7209    ]
7210
7211    def __init__(
7212        self,
7213        bind_interface=None,
7214        certificate_authority=None,
7215        client_certificate=None,
7216        client_key=None,
7217        database=None,
7218        egress_filter=None,
7219        healthy=None,
7220        hostname=None,
7221        id=None,
7222        name=None,
7223        override_database=None,
7224        password=None,
7225        port=None,
7226        port_override=None,
7227        secret_store_id=None,
7228        server_name=None,
7229        tags=None,
7230        username=None,
7231    ):
7232        self.bind_interface = bind_interface if bind_interface is not None else ''
7233        '''
7234         Bind interface
7235        '''
7236        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
7237        '''
7238
7239        '''
7240        self.client_certificate = client_certificate if client_certificate is not None else ''
7241        '''
7242
7243        '''
7244        self.client_key = client_key if client_key is not None else ''
7245        '''
7246
7247        '''
7248        self.database = database if database is not None else ''
7249        '''
7250
7251        '''
7252        self.egress_filter = egress_filter if egress_filter is not None else ''
7253        '''
7254         A filter applied to the routing logic to pin datasource to nodes.
7255        '''
7256        self.healthy = healthy if healthy is not None else False
7257        '''
7258         True if the datasource is reachable and the credentials are valid.
7259        '''
7260        self.hostname = hostname if hostname is not None else ''
7261        '''
7262
7263        '''
7264        self.id = id if id is not None else ''
7265        '''
7266         Unique identifier of the Resource.
7267        '''
7268        self.name = name if name is not None else ''
7269        '''
7270         Unique human-readable name of the Resource.
7271        '''
7272        self.override_database = override_database if override_database is not None else False
7273        '''
7274
7275        '''
7276        self.password = password if password is not None else ''
7277        '''
7278
7279        '''
7280        self.port = port if port is not None else 0
7281        '''
7282
7283        '''
7284        self.port_override = port_override if port_override is not None else 0
7285        '''
7286
7287        '''
7288        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7289        '''
7290         ID of the secret store containing credentials for this resource, if any.
7291        '''
7292        self.server_name = server_name if server_name is not None else ''
7293        '''
7294
7295        '''
7296        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7297        '''
7298         Tags is a map of key, value pairs.
7299        '''
7300        self.username = username if username is not None else ''
7301        '''
7302
7303        '''
7304
7305    def __repr__(self):
7306        return '<sdm.MTLSPostgres ' + \
7307            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7308            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
7309            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
7310            'client_key: ' + repr(self.client_key) + ' ' +\
7311            'database: ' + repr(self.database) + ' ' +\
7312            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7313            'healthy: ' + repr(self.healthy) + ' ' +\
7314            'hostname: ' + repr(self.hostname) + ' ' +\
7315            'id: ' + repr(self.id) + ' ' +\
7316            'name: ' + repr(self.name) + ' ' +\
7317            'override_database: ' + repr(self.override_database) + ' ' +\
7318            'password: ' + repr(self.password) + ' ' +\
7319            'port: ' + repr(self.port) + ' ' +\
7320            'port_override: ' + repr(self.port_override) + ' ' +\
7321            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7322            'server_name: ' + repr(self.server_name) + ' ' +\
7323            'tags: ' + repr(self.tags) + ' ' +\
7324            'username: ' + repr(self.username) + ' ' +\
7325            '>'
7326
7327    def to_dict(self):
7328        return {
7329            'bind_interface': self.bind_interface,
7330            'certificate_authority': self.certificate_authority,
7331            'client_certificate': self.client_certificate,
7332            'client_key': self.client_key,
7333            'database': self.database,
7334            'egress_filter': self.egress_filter,
7335            'healthy': self.healthy,
7336            'hostname': self.hostname,
7337            'id': self.id,
7338            'name': self.name,
7339            'override_database': self.override_database,
7340            'password': self.password,
7341            'port': self.port,
7342            'port_override': self.port_override,
7343            'secret_store_id': self.secret_store_id,
7344            'server_name': self.server_name,
7345            'tags': self.tags,
7346            'username': self.username,
7347        }
7348
7349    @classmethod
7350    def from_dict(cls, d):
7351        return cls(
7352            bind_interface=d.get('bind_interface'),
7353            certificate_authority=d.get('certificate_authority'),
7354            client_certificate=d.get('client_certificate'),
7355            client_key=d.get('client_key'),
7356            database=d.get('database'),
7357            egress_filter=d.get('egress_filter'),
7358            healthy=d.get('healthy'),
7359            hostname=d.get('hostname'),
7360            id=d.get('id'),
7361            name=d.get('name'),
7362            override_database=d.get('override_database'),
7363            password=d.get('password'),
7364            port=d.get('port'),
7365            port_override=d.get('port_override'),
7366            secret_store_id=d.get('secret_store_id'),
7367            server_name=d.get('server_name'),
7368            tags=d.get('tags'),
7369            username=d.get('username'),
7370        )
MTLSPostgres( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
7211    def __init__(
7212        self,
7213        bind_interface=None,
7214        certificate_authority=None,
7215        client_certificate=None,
7216        client_key=None,
7217        database=None,
7218        egress_filter=None,
7219        healthy=None,
7220        hostname=None,
7221        id=None,
7222        name=None,
7223        override_database=None,
7224        password=None,
7225        port=None,
7226        port_override=None,
7227        secret_store_id=None,
7228        server_name=None,
7229        tags=None,
7230        username=None,
7231    ):
7232        self.bind_interface = bind_interface if bind_interface is not None else ''
7233        '''
7234         Bind interface
7235        '''
7236        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
7237        '''
7238
7239        '''
7240        self.client_certificate = client_certificate if client_certificate is not None else ''
7241        '''
7242
7243        '''
7244        self.client_key = client_key if client_key is not None else ''
7245        '''
7246
7247        '''
7248        self.database = database if database is not None else ''
7249        '''
7250
7251        '''
7252        self.egress_filter = egress_filter if egress_filter is not None else ''
7253        '''
7254         A filter applied to the routing logic to pin datasource to nodes.
7255        '''
7256        self.healthy = healthy if healthy is not None else False
7257        '''
7258         True if the datasource is reachable and the credentials are valid.
7259        '''
7260        self.hostname = hostname if hostname is not None else ''
7261        '''
7262
7263        '''
7264        self.id = id if id is not None else ''
7265        '''
7266         Unique identifier of the Resource.
7267        '''
7268        self.name = name if name is not None else ''
7269        '''
7270         Unique human-readable name of the Resource.
7271        '''
7272        self.override_database = override_database if override_database is not None else False
7273        '''
7274
7275        '''
7276        self.password = password if password is not None else ''
7277        '''
7278
7279        '''
7280        self.port = port if port is not None else 0
7281        '''
7282
7283        '''
7284        self.port_override = port_override if port_override is not None else 0
7285        '''
7286
7287        '''
7288        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7289        '''
7290         ID of the secret store containing credentials for this resource, if any.
7291        '''
7292        self.server_name = server_name if server_name is not None else ''
7293        '''
7294
7295        '''
7296        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7297        '''
7298         Tags is a map of key, value pairs.
7299        '''
7300        self.username = username if username is not None else ''
7301        '''
7302
7303        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7327    def to_dict(self):
7328        return {
7329            'bind_interface': self.bind_interface,
7330            'certificate_authority': self.certificate_authority,
7331            'client_certificate': self.client_certificate,
7332            'client_key': self.client_key,
7333            'database': self.database,
7334            'egress_filter': self.egress_filter,
7335            'healthy': self.healthy,
7336            'hostname': self.hostname,
7337            'id': self.id,
7338            'name': self.name,
7339            'override_database': self.override_database,
7340            'password': self.password,
7341            'port': self.port,
7342            'port_override': self.port_override,
7343            'secret_store_id': self.secret_store_id,
7344            'server_name': self.server_name,
7345            'tags': self.tags,
7346            'username': self.username,
7347        }
@classmethod
def from_dict(cls, d)
7349    @classmethod
7350    def from_dict(cls, d):
7351        return cls(
7352            bind_interface=d.get('bind_interface'),
7353            certificate_authority=d.get('certificate_authority'),
7354            client_certificate=d.get('client_certificate'),
7355            client_key=d.get('client_key'),
7356            database=d.get('database'),
7357            egress_filter=d.get('egress_filter'),
7358            healthy=d.get('healthy'),
7359            hostname=d.get('hostname'),
7360            id=d.get('id'),
7361            name=d.get('name'),
7362            override_database=d.get('override_database'),
7363            password=d.get('password'),
7364            port=d.get('port'),
7365            port_override=d.get('port_override'),
7366            secret_store_id=d.get('secret_store_id'),
7367            server_name=d.get('server_name'),
7368            tags=d.get('tags'),
7369            username=d.get('username'),
7370        )
class Maria:
7373class Maria:
7374    '''
7375
7376    '''
7377    __slots__ = [
7378        'bind_interface',
7379        'database',
7380        'egress_filter',
7381        'healthy',
7382        'hostname',
7383        'id',
7384        'name',
7385        'password',
7386        'port',
7387        'port_override',
7388        'secret_store_id',
7389        'tags',
7390        'username',
7391    ]
7392
7393    def __init__(
7394        self,
7395        bind_interface=None,
7396        database=None,
7397        egress_filter=None,
7398        healthy=None,
7399        hostname=None,
7400        id=None,
7401        name=None,
7402        password=None,
7403        port=None,
7404        port_override=None,
7405        secret_store_id=None,
7406        tags=None,
7407        username=None,
7408    ):
7409        self.bind_interface = bind_interface if bind_interface is not None else ''
7410        '''
7411         Bind interface
7412        '''
7413        self.database = database if database is not None else ''
7414        '''
7415
7416        '''
7417        self.egress_filter = egress_filter if egress_filter is not None else ''
7418        '''
7419         A filter applied to the routing logic to pin datasource to nodes.
7420        '''
7421        self.healthy = healthy if healthy is not None else False
7422        '''
7423         True if the datasource is reachable and the credentials are valid.
7424        '''
7425        self.hostname = hostname if hostname is not None else ''
7426        '''
7427
7428        '''
7429        self.id = id if id is not None else ''
7430        '''
7431         Unique identifier of the Resource.
7432        '''
7433        self.name = name if name is not None else ''
7434        '''
7435         Unique human-readable name of the Resource.
7436        '''
7437        self.password = password if password is not None else ''
7438        '''
7439
7440        '''
7441        self.port = port if port is not None else 0
7442        '''
7443
7444        '''
7445        self.port_override = port_override if port_override is not None else 0
7446        '''
7447
7448        '''
7449        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7450        '''
7451         ID of the secret store containing credentials for this resource, if any.
7452        '''
7453        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7454        '''
7455         Tags is a map of key, value pairs.
7456        '''
7457        self.username = username if username is not None else ''
7458        '''
7459
7460        '''
7461
7462    def __repr__(self):
7463        return '<sdm.Maria ' + \
7464            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7465            'database: ' + repr(self.database) + ' ' +\
7466            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7467            'healthy: ' + repr(self.healthy) + ' ' +\
7468            'hostname: ' + repr(self.hostname) + ' ' +\
7469            'id: ' + repr(self.id) + ' ' +\
7470            'name: ' + repr(self.name) + ' ' +\
7471            'password: ' + repr(self.password) + ' ' +\
7472            'port: ' + repr(self.port) + ' ' +\
7473            'port_override: ' + repr(self.port_override) + ' ' +\
7474            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7475            'tags: ' + repr(self.tags) + ' ' +\
7476            'username: ' + repr(self.username) + ' ' +\
7477            '>'
7478
7479    def to_dict(self):
7480        return {
7481            'bind_interface': self.bind_interface,
7482            'database': self.database,
7483            'egress_filter': self.egress_filter,
7484            'healthy': self.healthy,
7485            'hostname': self.hostname,
7486            'id': self.id,
7487            'name': self.name,
7488            'password': self.password,
7489            'port': self.port,
7490            'port_override': self.port_override,
7491            'secret_store_id': self.secret_store_id,
7492            'tags': self.tags,
7493            'username': self.username,
7494        }
7495
7496    @classmethod
7497    def from_dict(cls, d):
7498        return cls(
7499            bind_interface=d.get('bind_interface'),
7500            database=d.get('database'),
7501            egress_filter=d.get('egress_filter'),
7502            healthy=d.get('healthy'),
7503            hostname=d.get('hostname'),
7504            id=d.get('id'),
7505            name=d.get('name'),
7506            password=d.get('password'),
7507            port=d.get('port'),
7508            port_override=d.get('port_override'),
7509            secret_store_id=d.get('secret_store_id'),
7510            tags=d.get('tags'),
7511            username=d.get('username'),
7512        )
Maria( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
7393    def __init__(
7394        self,
7395        bind_interface=None,
7396        database=None,
7397        egress_filter=None,
7398        healthy=None,
7399        hostname=None,
7400        id=None,
7401        name=None,
7402        password=None,
7403        port=None,
7404        port_override=None,
7405        secret_store_id=None,
7406        tags=None,
7407        username=None,
7408    ):
7409        self.bind_interface = bind_interface if bind_interface is not None else ''
7410        '''
7411         Bind interface
7412        '''
7413        self.database = database if database is not None else ''
7414        '''
7415
7416        '''
7417        self.egress_filter = egress_filter if egress_filter is not None else ''
7418        '''
7419         A filter applied to the routing logic to pin datasource to nodes.
7420        '''
7421        self.healthy = healthy if healthy is not None else False
7422        '''
7423         True if the datasource is reachable and the credentials are valid.
7424        '''
7425        self.hostname = hostname if hostname is not None else ''
7426        '''
7427
7428        '''
7429        self.id = id if id is not None else ''
7430        '''
7431         Unique identifier of the Resource.
7432        '''
7433        self.name = name if name is not None else ''
7434        '''
7435         Unique human-readable name of the Resource.
7436        '''
7437        self.password = password if password is not None else ''
7438        '''
7439
7440        '''
7441        self.port = port if port is not None else 0
7442        '''
7443
7444        '''
7445        self.port_override = port_override if port_override is not None else 0
7446        '''
7447
7448        '''
7449        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7450        '''
7451         ID of the secret store containing credentials for this resource, if any.
7452        '''
7453        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7454        '''
7455         Tags is a map of key, value pairs.
7456        '''
7457        self.username = username if username is not None else ''
7458        '''
7459
7460        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7479    def to_dict(self):
7480        return {
7481            'bind_interface': self.bind_interface,
7482            'database': self.database,
7483            'egress_filter': self.egress_filter,
7484            'healthy': self.healthy,
7485            'hostname': self.hostname,
7486            'id': self.id,
7487            'name': self.name,
7488            'password': self.password,
7489            'port': self.port,
7490            'port_override': self.port_override,
7491            'secret_store_id': self.secret_store_id,
7492            'tags': self.tags,
7493            'username': self.username,
7494        }
@classmethod
def from_dict(cls, d)
7496    @classmethod
7497    def from_dict(cls, d):
7498        return cls(
7499            bind_interface=d.get('bind_interface'),
7500            database=d.get('database'),
7501            egress_filter=d.get('egress_filter'),
7502            healthy=d.get('healthy'),
7503            hostname=d.get('hostname'),
7504            id=d.get('id'),
7505            name=d.get('name'),
7506            password=d.get('password'),
7507            port=d.get('port'),
7508            port_override=d.get('port_override'),
7509            secret_store_id=d.get('secret_store_id'),
7510            tags=d.get('tags'),
7511            username=d.get('username'),
7512        )
class Memcached:
7515class Memcached:
7516    '''
7517
7518    '''
7519    __slots__ = [
7520        'bind_interface',
7521        'egress_filter',
7522        'healthy',
7523        'hostname',
7524        'id',
7525        'name',
7526        'port',
7527        'port_override',
7528        'secret_store_id',
7529        'tags',
7530    ]
7531
7532    def __init__(
7533        self,
7534        bind_interface=None,
7535        egress_filter=None,
7536        healthy=None,
7537        hostname=None,
7538        id=None,
7539        name=None,
7540        port=None,
7541        port_override=None,
7542        secret_store_id=None,
7543        tags=None,
7544    ):
7545        self.bind_interface = bind_interface if bind_interface is not None else ''
7546        '''
7547         Bind interface
7548        '''
7549        self.egress_filter = egress_filter if egress_filter is not None else ''
7550        '''
7551         A filter applied to the routing logic to pin datasource to nodes.
7552        '''
7553        self.healthy = healthy if healthy is not None else False
7554        '''
7555         True if the datasource is reachable and the credentials are valid.
7556        '''
7557        self.hostname = hostname if hostname is not None else ''
7558        '''
7559
7560        '''
7561        self.id = id if id is not None else ''
7562        '''
7563         Unique identifier of the Resource.
7564        '''
7565        self.name = name if name is not None else ''
7566        '''
7567         Unique human-readable name of the Resource.
7568        '''
7569        self.port = port if port is not None else 0
7570        '''
7571
7572        '''
7573        self.port_override = port_override if port_override is not None else 0
7574        '''
7575
7576        '''
7577        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7578        '''
7579         ID of the secret store containing credentials for this resource, if any.
7580        '''
7581        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7582        '''
7583         Tags is a map of key, value pairs.
7584        '''
7585
7586    def __repr__(self):
7587        return '<sdm.Memcached ' + \
7588            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7589            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7590            'healthy: ' + repr(self.healthy) + ' ' +\
7591            'hostname: ' + repr(self.hostname) + ' ' +\
7592            'id: ' + repr(self.id) + ' ' +\
7593            'name: ' + repr(self.name) + ' ' +\
7594            'port: ' + repr(self.port) + ' ' +\
7595            'port_override: ' + repr(self.port_override) + ' ' +\
7596            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7597            'tags: ' + repr(self.tags) + ' ' +\
7598            '>'
7599
7600    def to_dict(self):
7601        return {
7602            'bind_interface': self.bind_interface,
7603            'egress_filter': self.egress_filter,
7604            'healthy': self.healthy,
7605            'hostname': self.hostname,
7606            'id': self.id,
7607            'name': self.name,
7608            'port': self.port,
7609            'port_override': self.port_override,
7610            'secret_store_id': self.secret_store_id,
7611            'tags': self.tags,
7612        }
7613
7614    @classmethod
7615    def from_dict(cls, d):
7616        return cls(
7617            bind_interface=d.get('bind_interface'),
7618            egress_filter=d.get('egress_filter'),
7619            healthy=d.get('healthy'),
7620            hostname=d.get('hostname'),
7621            id=d.get('id'),
7622            name=d.get('name'),
7623            port=d.get('port'),
7624            port_override=d.get('port_override'),
7625            secret_store_id=d.get('secret_store_id'),
7626            tags=d.get('tags'),
7627        )
Memcached( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
7532    def __init__(
7533        self,
7534        bind_interface=None,
7535        egress_filter=None,
7536        healthy=None,
7537        hostname=None,
7538        id=None,
7539        name=None,
7540        port=None,
7541        port_override=None,
7542        secret_store_id=None,
7543        tags=None,
7544    ):
7545        self.bind_interface = bind_interface if bind_interface is not None else ''
7546        '''
7547         Bind interface
7548        '''
7549        self.egress_filter = egress_filter if egress_filter is not None else ''
7550        '''
7551         A filter applied to the routing logic to pin datasource to nodes.
7552        '''
7553        self.healthy = healthy if healthy is not None else False
7554        '''
7555         True if the datasource is reachable and the credentials are valid.
7556        '''
7557        self.hostname = hostname if hostname is not None else ''
7558        '''
7559
7560        '''
7561        self.id = id if id is not None else ''
7562        '''
7563         Unique identifier of the Resource.
7564        '''
7565        self.name = name if name is not None else ''
7566        '''
7567         Unique human-readable name of the Resource.
7568        '''
7569        self.port = port if port is not None else 0
7570        '''
7571
7572        '''
7573        self.port_override = port_override if port_override is not None else 0
7574        '''
7575
7576        '''
7577        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7578        '''
7579         ID of the secret store containing credentials for this resource, if any.
7580        '''
7581        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7582        '''
7583         Tags is a map of key, value pairs.
7584        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
7600    def to_dict(self):
7601        return {
7602            'bind_interface': self.bind_interface,
7603            'egress_filter': self.egress_filter,
7604            'healthy': self.healthy,
7605            'hostname': self.hostname,
7606            'id': self.id,
7607            'name': self.name,
7608            'port': self.port,
7609            'port_override': self.port_override,
7610            'secret_store_id': self.secret_store_id,
7611            'tags': self.tags,
7612        }
@classmethod
def from_dict(cls, d)
7614    @classmethod
7615    def from_dict(cls, d):
7616        return cls(
7617            bind_interface=d.get('bind_interface'),
7618            egress_filter=d.get('egress_filter'),
7619            healthy=d.get('healthy'),
7620            hostname=d.get('hostname'),
7621            id=d.get('id'),
7622            name=d.get('name'),
7623            port=d.get('port'),
7624            port_override=d.get('port_override'),
7625            secret_store_id=d.get('secret_store_id'),
7626            tags=d.get('tags'),
7627        )
class Memsql:
7630class Memsql:
7631    '''
7632
7633    '''
7634    __slots__ = [
7635        'bind_interface',
7636        'database',
7637        'egress_filter',
7638        'healthy',
7639        'hostname',
7640        'id',
7641        'name',
7642        'password',
7643        'port',
7644        'port_override',
7645        'secret_store_id',
7646        'tags',
7647        'username',
7648    ]
7649
7650    def __init__(
7651        self,
7652        bind_interface=None,
7653        database=None,
7654        egress_filter=None,
7655        healthy=None,
7656        hostname=None,
7657        id=None,
7658        name=None,
7659        password=None,
7660        port=None,
7661        port_override=None,
7662        secret_store_id=None,
7663        tags=None,
7664        username=None,
7665    ):
7666        self.bind_interface = bind_interface if bind_interface is not None else ''
7667        '''
7668         Bind interface
7669        '''
7670        self.database = database if database is not None else ''
7671        '''
7672
7673        '''
7674        self.egress_filter = egress_filter if egress_filter is not None else ''
7675        '''
7676         A filter applied to the routing logic to pin datasource to nodes.
7677        '''
7678        self.healthy = healthy if healthy is not None else False
7679        '''
7680         True if the datasource is reachable and the credentials are valid.
7681        '''
7682        self.hostname = hostname if hostname is not None else ''
7683        '''
7684
7685        '''
7686        self.id = id if id is not None else ''
7687        '''
7688         Unique identifier of the Resource.
7689        '''
7690        self.name = name if name is not None else ''
7691        '''
7692         Unique human-readable name of the Resource.
7693        '''
7694        self.password = password if password is not None else ''
7695        '''
7696
7697        '''
7698        self.port = port if port is not None else 0
7699        '''
7700
7701        '''
7702        self.port_override = port_override if port_override is not None else 0
7703        '''
7704
7705        '''
7706        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7707        '''
7708         ID of the secret store containing credentials for this resource, if any.
7709        '''
7710        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7711        '''
7712         Tags is a map of key, value pairs.
7713        '''
7714        self.username = username if username is not None else ''
7715        '''
7716
7717        '''
7718
7719    def __repr__(self):
7720        return '<sdm.Memsql ' + \
7721            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7722            'database: ' + repr(self.database) + ' ' +\
7723            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7724            'healthy: ' + repr(self.healthy) + ' ' +\
7725            'hostname: ' + repr(self.hostname) + ' ' +\
7726            'id: ' + repr(self.id) + ' ' +\
7727            'name: ' + repr(self.name) + ' ' +\
7728            'password: ' + repr(self.password) + ' ' +\
7729            'port: ' + repr(self.port) + ' ' +\
7730            'port_override: ' + repr(self.port_override) + ' ' +\
7731            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7732            'tags: ' + repr(self.tags) + ' ' +\
7733            'username: ' + repr(self.username) + ' ' +\
7734            '>'
7735
7736    def to_dict(self):
7737        return {
7738            'bind_interface': self.bind_interface,
7739            'database': self.database,
7740            'egress_filter': self.egress_filter,
7741            'healthy': self.healthy,
7742            'hostname': self.hostname,
7743            'id': self.id,
7744            'name': self.name,
7745            'password': self.password,
7746            'port': self.port,
7747            'port_override': self.port_override,
7748            'secret_store_id': self.secret_store_id,
7749            'tags': self.tags,
7750            'username': self.username,
7751        }
7752
7753    @classmethod
7754    def from_dict(cls, d):
7755        return cls(
7756            bind_interface=d.get('bind_interface'),
7757            database=d.get('database'),
7758            egress_filter=d.get('egress_filter'),
7759            healthy=d.get('healthy'),
7760            hostname=d.get('hostname'),
7761            id=d.get('id'),
7762            name=d.get('name'),
7763            password=d.get('password'),
7764            port=d.get('port'),
7765            port_override=d.get('port_override'),
7766            secret_store_id=d.get('secret_store_id'),
7767            tags=d.get('tags'),
7768            username=d.get('username'),
7769        )
Memsql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
7650    def __init__(
7651        self,
7652        bind_interface=None,
7653        database=None,
7654        egress_filter=None,
7655        healthy=None,
7656        hostname=None,
7657        id=None,
7658        name=None,
7659        password=None,
7660        port=None,
7661        port_override=None,
7662        secret_store_id=None,
7663        tags=None,
7664        username=None,
7665    ):
7666        self.bind_interface = bind_interface if bind_interface is not None else ''
7667        '''
7668         Bind interface
7669        '''
7670        self.database = database if database is not None else ''
7671        '''
7672
7673        '''
7674        self.egress_filter = egress_filter if egress_filter is not None else ''
7675        '''
7676         A filter applied to the routing logic to pin datasource to nodes.
7677        '''
7678        self.healthy = healthy if healthy is not None else False
7679        '''
7680         True if the datasource is reachable and the credentials are valid.
7681        '''
7682        self.hostname = hostname if hostname is not None else ''
7683        '''
7684
7685        '''
7686        self.id = id if id is not None else ''
7687        '''
7688         Unique identifier of the Resource.
7689        '''
7690        self.name = name if name is not None else ''
7691        '''
7692         Unique human-readable name of the Resource.
7693        '''
7694        self.password = password if password is not None else ''
7695        '''
7696
7697        '''
7698        self.port = port if port is not None else 0
7699        '''
7700
7701        '''
7702        self.port_override = port_override if port_override is not None else 0
7703        '''
7704
7705        '''
7706        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7707        '''
7708         ID of the secret store containing credentials for this resource, if any.
7709        '''
7710        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7711        '''
7712         Tags is a map of key, value pairs.
7713        '''
7714        self.username = username if username is not None else ''
7715        '''
7716
7717        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7736    def to_dict(self):
7737        return {
7738            'bind_interface': self.bind_interface,
7739            'database': self.database,
7740            'egress_filter': self.egress_filter,
7741            'healthy': self.healthy,
7742            'hostname': self.hostname,
7743            'id': self.id,
7744            'name': self.name,
7745            'password': self.password,
7746            'port': self.port,
7747            'port_override': self.port_override,
7748            'secret_store_id': self.secret_store_id,
7749            'tags': self.tags,
7750            'username': self.username,
7751        }
@classmethod
def from_dict(cls, d)
7753    @classmethod
7754    def from_dict(cls, d):
7755        return cls(
7756            bind_interface=d.get('bind_interface'),
7757            database=d.get('database'),
7758            egress_filter=d.get('egress_filter'),
7759            healthy=d.get('healthy'),
7760            hostname=d.get('hostname'),
7761            id=d.get('id'),
7762            name=d.get('name'),
7763            password=d.get('password'),
7764            port=d.get('port'),
7765            port_override=d.get('port_override'),
7766            secret_store_id=d.get('secret_store_id'),
7767            tags=d.get('tags'),
7768            username=d.get('username'),
7769        )
class MongoHost:
7772class MongoHost:
7773    '''
7774
7775    '''
7776    __slots__ = [
7777        'auth_database',
7778        'bind_interface',
7779        'egress_filter',
7780        'healthy',
7781        'hostname',
7782        'id',
7783        'name',
7784        'password',
7785        'port',
7786        'port_override',
7787        'secret_store_id',
7788        'tags',
7789        'tls_required',
7790        'username',
7791    ]
7792
7793    def __init__(
7794        self,
7795        auth_database=None,
7796        bind_interface=None,
7797        egress_filter=None,
7798        healthy=None,
7799        hostname=None,
7800        id=None,
7801        name=None,
7802        password=None,
7803        port=None,
7804        port_override=None,
7805        secret_store_id=None,
7806        tags=None,
7807        tls_required=None,
7808        username=None,
7809    ):
7810        self.auth_database = auth_database if auth_database is not None else ''
7811        '''
7812
7813        '''
7814        self.bind_interface = bind_interface if bind_interface is not None else ''
7815        '''
7816         Bind interface
7817        '''
7818        self.egress_filter = egress_filter if egress_filter is not None else ''
7819        '''
7820         A filter applied to the routing logic to pin datasource to nodes.
7821        '''
7822        self.healthy = healthy if healthy is not None else False
7823        '''
7824         True if the datasource is reachable and the credentials are valid.
7825        '''
7826        self.hostname = hostname if hostname is not None else ''
7827        '''
7828
7829        '''
7830        self.id = id if id is not None else ''
7831        '''
7832         Unique identifier of the Resource.
7833        '''
7834        self.name = name if name is not None else ''
7835        '''
7836         Unique human-readable name of the Resource.
7837        '''
7838        self.password = password if password is not None else ''
7839        '''
7840
7841        '''
7842        self.port = port if port is not None else 0
7843        '''
7844
7845        '''
7846        self.port_override = port_override if port_override is not None else 0
7847        '''
7848
7849        '''
7850        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7851        '''
7852         ID of the secret store containing credentials for this resource, if any.
7853        '''
7854        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7855        '''
7856         Tags is a map of key, value pairs.
7857        '''
7858        self.tls_required = tls_required if tls_required is not None else False
7859        '''
7860
7861        '''
7862        self.username = username if username is not None else ''
7863        '''
7864
7865        '''
7866
7867    def __repr__(self):
7868        return '<sdm.MongoHost ' + \
7869            'auth_database: ' + repr(self.auth_database) + ' ' +\
7870            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7871            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7872            'healthy: ' + repr(self.healthy) + ' ' +\
7873            'hostname: ' + repr(self.hostname) + ' ' +\
7874            'id: ' + repr(self.id) + ' ' +\
7875            'name: ' + repr(self.name) + ' ' +\
7876            'password: ' + repr(self.password) + ' ' +\
7877            'port: ' + repr(self.port) + ' ' +\
7878            'port_override: ' + repr(self.port_override) + ' ' +\
7879            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7880            'tags: ' + repr(self.tags) + ' ' +\
7881            'tls_required: ' + repr(self.tls_required) + ' ' +\
7882            'username: ' + repr(self.username) + ' ' +\
7883            '>'
7884
7885    def to_dict(self):
7886        return {
7887            'auth_database': self.auth_database,
7888            'bind_interface': self.bind_interface,
7889            'egress_filter': self.egress_filter,
7890            'healthy': self.healthy,
7891            'hostname': self.hostname,
7892            'id': self.id,
7893            'name': self.name,
7894            'password': self.password,
7895            'port': self.port,
7896            'port_override': self.port_override,
7897            'secret_store_id': self.secret_store_id,
7898            'tags': self.tags,
7899            'tls_required': self.tls_required,
7900            'username': self.username,
7901        }
7902
7903    @classmethod
7904    def from_dict(cls, d):
7905        return cls(
7906            auth_database=d.get('auth_database'),
7907            bind_interface=d.get('bind_interface'),
7908            egress_filter=d.get('egress_filter'),
7909            healthy=d.get('healthy'),
7910            hostname=d.get('hostname'),
7911            id=d.get('id'),
7912            name=d.get('name'),
7913            password=d.get('password'),
7914            port=d.get('port'),
7915            port_override=d.get('port_override'),
7916            secret_store_id=d.get('secret_store_id'),
7917            tags=d.get('tags'),
7918            tls_required=d.get('tls_required'),
7919            username=d.get('username'),
7920        )
MongoHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7793    def __init__(
7794        self,
7795        auth_database=None,
7796        bind_interface=None,
7797        egress_filter=None,
7798        healthy=None,
7799        hostname=None,
7800        id=None,
7801        name=None,
7802        password=None,
7803        port=None,
7804        port_override=None,
7805        secret_store_id=None,
7806        tags=None,
7807        tls_required=None,
7808        username=None,
7809    ):
7810        self.auth_database = auth_database if auth_database is not None else ''
7811        '''
7812
7813        '''
7814        self.bind_interface = bind_interface if bind_interface is not None else ''
7815        '''
7816         Bind interface
7817        '''
7818        self.egress_filter = egress_filter if egress_filter is not None else ''
7819        '''
7820         A filter applied to the routing logic to pin datasource to nodes.
7821        '''
7822        self.healthy = healthy if healthy is not None else False
7823        '''
7824         True if the datasource is reachable and the credentials are valid.
7825        '''
7826        self.hostname = hostname if hostname is not None else ''
7827        '''
7828
7829        '''
7830        self.id = id if id is not None else ''
7831        '''
7832         Unique identifier of the Resource.
7833        '''
7834        self.name = name if name is not None else ''
7835        '''
7836         Unique human-readable name of the Resource.
7837        '''
7838        self.password = password if password is not None else ''
7839        '''
7840
7841        '''
7842        self.port = port if port is not None else 0
7843        '''
7844
7845        '''
7846        self.port_override = port_override if port_override is not None else 0
7847        '''
7848
7849        '''
7850        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7851        '''
7852         ID of the secret store containing credentials for this resource, if any.
7853        '''
7854        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7855        '''
7856         Tags is a map of key, value pairs.
7857        '''
7858        self.tls_required = tls_required if tls_required is not None else False
7859        '''
7860
7861        '''
7862        self.username = username if username is not None else ''
7863        '''
7864
7865        '''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7885    def to_dict(self):
7886        return {
7887            'auth_database': self.auth_database,
7888            'bind_interface': self.bind_interface,
7889            'egress_filter': self.egress_filter,
7890            'healthy': self.healthy,
7891            'hostname': self.hostname,
7892            'id': self.id,
7893            'name': self.name,
7894            'password': self.password,
7895            'port': self.port,
7896            'port_override': self.port_override,
7897            'secret_store_id': self.secret_store_id,
7898            'tags': self.tags,
7899            'tls_required': self.tls_required,
7900            'username': self.username,
7901        }
@classmethod
def from_dict(cls, d)
7903    @classmethod
7904    def from_dict(cls, d):
7905        return cls(
7906            auth_database=d.get('auth_database'),
7907            bind_interface=d.get('bind_interface'),
7908            egress_filter=d.get('egress_filter'),
7909            healthy=d.get('healthy'),
7910            hostname=d.get('hostname'),
7911            id=d.get('id'),
7912            name=d.get('name'),
7913            password=d.get('password'),
7914            port=d.get('port'),
7915            port_override=d.get('port_override'),
7916            secret_store_id=d.get('secret_store_id'),
7917            tags=d.get('tags'),
7918            tls_required=d.get('tls_required'),
7919            username=d.get('username'),
7920        )
class MongoLegacyHost:
7923class MongoLegacyHost:
7924    '''
7925
7926    '''
7927    __slots__ = [
7928        'auth_database',
7929        'bind_interface',
7930        'egress_filter',
7931        'healthy',
7932        'hostname',
7933        'id',
7934        'name',
7935        'password',
7936        'port',
7937        'port_override',
7938        'replica_set',
7939        'secret_store_id',
7940        'tags',
7941        'tls_required',
7942        'username',
7943    ]
7944
7945    def __init__(
7946        self,
7947        auth_database=None,
7948        bind_interface=None,
7949        egress_filter=None,
7950        healthy=None,
7951        hostname=None,
7952        id=None,
7953        name=None,
7954        password=None,
7955        port=None,
7956        port_override=None,
7957        replica_set=None,
7958        secret_store_id=None,
7959        tags=None,
7960        tls_required=None,
7961        username=None,
7962    ):
7963        self.auth_database = auth_database if auth_database is not None else ''
7964        '''
7965
7966        '''
7967        self.bind_interface = bind_interface if bind_interface is not None else ''
7968        '''
7969         Bind interface
7970        '''
7971        self.egress_filter = egress_filter if egress_filter is not None else ''
7972        '''
7973         A filter applied to the routing logic to pin datasource to nodes.
7974        '''
7975        self.healthy = healthy if healthy is not None else False
7976        '''
7977         True if the datasource is reachable and the credentials are valid.
7978        '''
7979        self.hostname = hostname if hostname is not None else ''
7980        '''
7981
7982        '''
7983        self.id = id if id is not None else ''
7984        '''
7985         Unique identifier of the Resource.
7986        '''
7987        self.name = name if name is not None else ''
7988        '''
7989         Unique human-readable name of the Resource.
7990        '''
7991        self.password = password if password is not None else ''
7992        '''
7993
7994        '''
7995        self.port = port if port is not None else 0
7996        '''
7997
7998        '''
7999        self.port_override = port_override if port_override is not None else 0
8000        '''
8001
8002        '''
8003        self.replica_set = replica_set if replica_set is not None else ''
8004        '''
8005
8006        '''
8007        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8008        '''
8009         ID of the secret store containing credentials for this resource, if any.
8010        '''
8011        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8012        '''
8013         Tags is a map of key, value pairs.
8014        '''
8015        self.tls_required = tls_required if tls_required is not None else False
8016        '''
8017
8018        '''
8019        self.username = username if username is not None else ''
8020        '''
8021
8022        '''
8023
8024    def __repr__(self):
8025        return '<sdm.MongoLegacyHost ' + \
8026            'auth_database: ' + repr(self.auth_database) + ' ' +\
8027            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8028            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8029            'healthy: ' + repr(self.healthy) + ' ' +\
8030            'hostname: ' + repr(self.hostname) + ' ' +\
8031            'id: ' + repr(self.id) + ' ' +\
8032            'name: ' + repr(self.name) + ' ' +\
8033            'password: ' + repr(self.password) + ' ' +\
8034            'port: ' + repr(self.port) + ' ' +\
8035            'port_override: ' + repr(self.port_override) + ' ' +\
8036            'replica_set: ' + repr(self.replica_set) + ' ' +\
8037            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8038            'tags: ' + repr(self.tags) + ' ' +\
8039            'tls_required: ' + repr(self.tls_required) + ' ' +\
8040            'username: ' + repr(self.username) + ' ' +\
8041            '>'
8042
8043    def to_dict(self):
8044        return {
8045            'auth_database': self.auth_database,
8046            'bind_interface': self.bind_interface,
8047            'egress_filter': self.egress_filter,
8048            'healthy': self.healthy,
8049            'hostname': self.hostname,
8050            'id': self.id,
8051            'name': self.name,
8052            'password': self.password,
8053            'port': self.port,
8054            'port_override': self.port_override,
8055            'replica_set': self.replica_set,
8056            'secret_store_id': self.secret_store_id,
8057            'tags': self.tags,
8058            'tls_required': self.tls_required,
8059            'username': self.username,
8060        }
8061
8062    @classmethod
8063    def from_dict(cls, d):
8064        return cls(
8065            auth_database=d.get('auth_database'),
8066            bind_interface=d.get('bind_interface'),
8067            egress_filter=d.get('egress_filter'),
8068            healthy=d.get('healthy'),
8069            hostname=d.get('hostname'),
8070            id=d.get('id'),
8071            name=d.get('name'),
8072            password=d.get('password'),
8073            port=d.get('port'),
8074            port_override=d.get('port_override'),
8075            replica_set=d.get('replica_set'),
8076            secret_store_id=d.get('secret_store_id'),
8077            tags=d.get('tags'),
8078            tls_required=d.get('tls_required'),
8079            username=d.get('username'),
8080        )
MongoLegacyHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7945    def __init__(
7946        self,
7947        auth_database=None,
7948        bind_interface=None,
7949        egress_filter=None,
7950        healthy=None,
7951        hostname=None,
7952        id=None,
7953        name=None,
7954        password=None,
7955        port=None,
7956        port_override=None,
7957        replica_set=None,
7958        secret_store_id=None,
7959        tags=None,
7960        tls_required=None,
7961        username=None,
7962    ):
7963        self.auth_database = auth_database if auth_database is not None else ''
7964        '''
7965
7966        '''
7967        self.bind_interface = bind_interface if bind_interface is not None else ''
7968        '''
7969         Bind interface
7970        '''
7971        self.egress_filter = egress_filter if egress_filter is not None else ''
7972        '''
7973         A filter applied to the routing logic to pin datasource to nodes.
7974        '''
7975        self.healthy = healthy if healthy is not None else False
7976        '''
7977         True if the datasource is reachable and the credentials are valid.
7978        '''
7979        self.hostname = hostname if hostname is not None else ''
7980        '''
7981
7982        '''
7983        self.id = id if id is not None else ''
7984        '''
7985         Unique identifier of the Resource.
7986        '''
7987        self.name = name if name is not None else ''
7988        '''
7989         Unique human-readable name of the Resource.
7990        '''
7991        self.password = password if password is not None else ''
7992        '''
7993
7994        '''
7995        self.port = port if port is not None else 0
7996        '''
7997
7998        '''
7999        self.port_override = port_override if port_override is not None else 0
8000        '''
8001
8002        '''
8003        self.replica_set = replica_set if replica_set is not None else ''
8004        '''
8005
8006        '''
8007        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8008        '''
8009         ID of the secret store containing credentials for this resource, if any.
8010        '''
8011        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8012        '''
8013         Tags is a map of key, value pairs.
8014        '''
8015        self.tls_required = tls_required if tls_required is not None else False
8016        '''
8017
8018        '''
8019        self.username = username if username is not None else ''
8020        '''
8021
8022        '''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8043    def to_dict(self):
8044        return {
8045            'auth_database': self.auth_database,
8046            'bind_interface': self.bind_interface,
8047            'egress_filter': self.egress_filter,
8048            'healthy': self.healthy,
8049            'hostname': self.hostname,
8050            'id': self.id,
8051            'name': self.name,
8052            'password': self.password,
8053            'port': self.port,
8054            'port_override': self.port_override,
8055            'replica_set': self.replica_set,
8056            'secret_store_id': self.secret_store_id,
8057            'tags': self.tags,
8058            'tls_required': self.tls_required,
8059            'username': self.username,
8060        }
@classmethod
def from_dict(cls, d)
8062    @classmethod
8063    def from_dict(cls, d):
8064        return cls(
8065            auth_database=d.get('auth_database'),
8066            bind_interface=d.get('bind_interface'),
8067            egress_filter=d.get('egress_filter'),
8068            healthy=d.get('healthy'),
8069            hostname=d.get('hostname'),
8070            id=d.get('id'),
8071            name=d.get('name'),
8072            password=d.get('password'),
8073            port=d.get('port'),
8074            port_override=d.get('port_override'),
8075            replica_set=d.get('replica_set'),
8076            secret_store_id=d.get('secret_store_id'),
8077            tags=d.get('tags'),
8078            tls_required=d.get('tls_required'),
8079            username=d.get('username'),
8080        )
class MongoLegacyReplicaset:
8083class MongoLegacyReplicaset:
8084    '''
8085
8086    '''
8087    __slots__ = [
8088        'auth_database',
8089        'bind_interface',
8090        'connect_to_replica',
8091        'egress_filter',
8092        'healthy',
8093        'hostname',
8094        'id',
8095        'name',
8096        'password',
8097        'port',
8098        'port_override',
8099        'replica_set',
8100        'secret_store_id',
8101        'tags',
8102        'tls_required',
8103        'username',
8104    ]
8105
8106    def __init__(
8107        self,
8108        auth_database=None,
8109        bind_interface=None,
8110        connect_to_replica=None,
8111        egress_filter=None,
8112        healthy=None,
8113        hostname=None,
8114        id=None,
8115        name=None,
8116        password=None,
8117        port=None,
8118        port_override=None,
8119        replica_set=None,
8120        secret_store_id=None,
8121        tags=None,
8122        tls_required=None,
8123        username=None,
8124    ):
8125        self.auth_database = auth_database if auth_database is not None else ''
8126        '''
8127
8128        '''
8129        self.bind_interface = bind_interface if bind_interface is not None else ''
8130        '''
8131         Bind interface
8132        '''
8133        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
8134        '''
8135
8136        '''
8137        self.egress_filter = egress_filter if egress_filter is not None else ''
8138        '''
8139         A filter applied to the routing logic to pin datasource to nodes.
8140        '''
8141        self.healthy = healthy if healthy is not None else False
8142        '''
8143         True if the datasource is reachable and the credentials are valid.
8144        '''
8145        self.hostname = hostname if hostname is not None else ''
8146        '''
8147
8148        '''
8149        self.id = id if id is not None else ''
8150        '''
8151         Unique identifier of the Resource.
8152        '''
8153        self.name = name if name is not None else ''
8154        '''
8155         Unique human-readable name of the Resource.
8156        '''
8157        self.password = password if password is not None else ''
8158        '''
8159
8160        '''
8161        self.port = port if port is not None else 0
8162        '''
8163
8164        '''
8165        self.port_override = port_override if port_override is not None else 0
8166        '''
8167
8168        '''
8169        self.replica_set = replica_set if replica_set is not None else ''
8170        '''
8171
8172        '''
8173        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8174        '''
8175         ID of the secret store containing credentials for this resource, if any.
8176        '''
8177        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8178        '''
8179         Tags is a map of key, value pairs.
8180        '''
8181        self.tls_required = tls_required if tls_required is not None else False
8182        '''
8183
8184        '''
8185        self.username = username if username is not None else ''
8186        '''
8187
8188        '''
8189
8190    def __repr__(self):
8191        return '<sdm.MongoLegacyReplicaset ' + \
8192            'auth_database: ' + repr(self.auth_database) + ' ' +\
8193            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8194            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
8195            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8196            'healthy: ' + repr(self.healthy) + ' ' +\
8197            'hostname: ' + repr(self.hostname) + ' ' +\
8198            'id: ' + repr(self.id) + ' ' +\
8199            'name: ' + repr(self.name) + ' ' +\
8200            'password: ' + repr(self.password) + ' ' +\
8201            'port: ' + repr(self.port) + ' ' +\
8202            'port_override: ' + repr(self.port_override) + ' ' +\
8203            'replica_set: ' + repr(self.replica_set) + ' ' +\
8204            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8205            'tags: ' + repr(self.tags) + ' ' +\
8206            'tls_required: ' + repr(self.tls_required) + ' ' +\
8207            'username: ' + repr(self.username) + ' ' +\
8208            '>'
8209
8210    def to_dict(self):
8211        return {
8212            'auth_database': self.auth_database,
8213            'bind_interface': self.bind_interface,
8214            'connect_to_replica': self.connect_to_replica,
8215            'egress_filter': self.egress_filter,
8216            'healthy': self.healthy,
8217            'hostname': self.hostname,
8218            'id': self.id,
8219            'name': self.name,
8220            'password': self.password,
8221            'port': self.port,
8222            'port_override': self.port_override,
8223            'replica_set': self.replica_set,
8224            'secret_store_id': self.secret_store_id,
8225            'tags': self.tags,
8226            'tls_required': self.tls_required,
8227            'username': self.username,
8228        }
8229
8230    @classmethod
8231    def from_dict(cls, d):
8232        return cls(
8233            auth_database=d.get('auth_database'),
8234            bind_interface=d.get('bind_interface'),
8235            connect_to_replica=d.get('connect_to_replica'),
8236            egress_filter=d.get('egress_filter'),
8237            healthy=d.get('healthy'),
8238            hostname=d.get('hostname'),
8239            id=d.get('id'),
8240            name=d.get('name'),
8241            password=d.get('password'),
8242            port=d.get('port'),
8243            port_override=d.get('port_override'),
8244            replica_set=d.get('replica_set'),
8245            secret_store_id=d.get('secret_store_id'),
8246            tags=d.get('tags'),
8247            tls_required=d.get('tls_required'),
8248            username=d.get('username'),
8249        )
MongoLegacyReplicaset( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8106    def __init__(
8107        self,
8108        auth_database=None,
8109        bind_interface=None,
8110        connect_to_replica=None,
8111        egress_filter=None,
8112        healthy=None,
8113        hostname=None,
8114        id=None,
8115        name=None,
8116        password=None,
8117        port=None,
8118        port_override=None,
8119        replica_set=None,
8120        secret_store_id=None,
8121        tags=None,
8122        tls_required=None,
8123        username=None,
8124    ):
8125        self.auth_database = auth_database if auth_database is not None else ''
8126        '''
8127
8128        '''
8129        self.bind_interface = bind_interface if bind_interface is not None else ''
8130        '''
8131         Bind interface
8132        '''
8133        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
8134        '''
8135
8136        '''
8137        self.egress_filter = egress_filter if egress_filter is not None else ''
8138        '''
8139         A filter applied to the routing logic to pin datasource to nodes.
8140        '''
8141        self.healthy = healthy if healthy is not None else False
8142        '''
8143         True if the datasource is reachable and the credentials are valid.
8144        '''
8145        self.hostname = hostname if hostname is not None else ''
8146        '''
8147
8148        '''
8149        self.id = id if id is not None else ''
8150        '''
8151         Unique identifier of the Resource.
8152        '''
8153        self.name = name if name is not None else ''
8154        '''
8155         Unique human-readable name of the Resource.
8156        '''
8157        self.password = password if password is not None else ''
8158        '''
8159
8160        '''
8161        self.port = port if port is not None else 0
8162        '''
8163
8164        '''
8165        self.port_override = port_override if port_override is not None else 0
8166        '''
8167
8168        '''
8169        self.replica_set = replica_set if replica_set is not None else ''
8170        '''
8171
8172        '''
8173        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8174        '''
8175         ID of the secret store containing credentials for this resource, if any.
8176        '''
8177        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8178        '''
8179         Tags is a map of key, value pairs.
8180        '''
8181        self.tls_required = tls_required if tls_required is not None else False
8182        '''
8183
8184        '''
8185        self.username = username if username is not None else ''
8186        '''
8187
8188        '''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8210    def to_dict(self):
8211        return {
8212            'auth_database': self.auth_database,
8213            'bind_interface': self.bind_interface,
8214            'connect_to_replica': self.connect_to_replica,
8215            'egress_filter': self.egress_filter,
8216            'healthy': self.healthy,
8217            'hostname': self.hostname,
8218            'id': self.id,
8219            'name': self.name,
8220            'password': self.password,
8221            'port': self.port,
8222            'port_override': self.port_override,
8223            'replica_set': self.replica_set,
8224            'secret_store_id': self.secret_store_id,
8225            'tags': self.tags,
8226            'tls_required': self.tls_required,
8227            'username': self.username,
8228        }
@classmethod
def from_dict(cls, d)
8230    @classmethod
8231    def from_dict(cls, d):
8232        return cls(
8233            auth_database=d.get('auth_database'),
8234            bind_interface=d.get('bind_interface'),
8235            connect_to_replica=d.get('connect_to_replica'),
8236            egress_filter=d.get('egress_filter'),
8237            healthy=d.get('healthy'),
8238            hostname=d.get('hostname'),
8239            id=d.get('id'),
8240            name=d.get('name'),
8241            password=d.get('password'),
8242            port=d.get('port'),
8243            port_override=d.get('port_override'),
8244            replica_set=d.get('replica_set'),
8245            secret_store_id=d.get('secret_store_id'),
8246            tags=d.get('tags'),
8247            tls_required=d.get('tls_required'),
8248            username=d.get('username'),
8249        )
class MongoReplicaSet:
8252class MongoReplicaSet:
8253    '''
8254
8255    '''
8256    __slots__ = [
8257        'auth_database',
8258        'bind_interface',
8259        'connect_to_replica',
8260        'egress_filter',
8261        'healthy',
8262        'hostname',
8263        'id',
8264        'name',
8265        'password',
8266        'port',
8267        'port_override',
8268        'replica_set',
8269        'secret_store_id',
8270        'tags',
8271        'tls_required',
8272        'username',
8273    ]
8274
8275    def __init__(
8276        self,
8277        auth_database=None,
8278        bind_interface=None,
8279        connect_to_replica=None,
8280        egress_filter=None,
8281        healthy=None,
8282        hostname=None,
8283        id=None,
8284        name=None,
8285        password=None,
8286        port=None,
8287        port_override=None,
8288        replica_set=None,
8289        secret_store_id=None,
8290        tags=None,
8291        tls_required=None,
8292        username=None,
8293    ):
8294        self.auth_database = auth_database if auth_database is not None else ''
8295        '''
8296
8297        '''
8298        self.bind_interface = bind_interface if bind_interface is not None else ''
8299        '''
8300         Bind interface
8301        '''
8302        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
8303        '''
8304
8305        '''
8306        self.egress_filter = egress_filter if egress_filter is not None else ''
8307        '''
8308         A filter applied to the routing logic to pin datasource to nodes.
8309        '''
8310        self.healthy = healthy if healthy is not None else False
8311        '''
8312         True if the datasource is reachable and the credentials are valid.
8313        '''
8314        self.hostname = hostname if hostname is not None else ''
8315        '''
8316
8317        '''
8318        self.id = id if id is not None else ''
8319        '''
8320         Unique identifier of the Resource.
8321        '''
8322        self.name = name if name is not None else ''
8323        '''
8324         Unique human-readable name of the Resource.
8325        '''
8326        self.password = password if password is not None else ''
8327        '''
8328
8329        '''
8330        self.port = port if port is not None else 0
8331        '''
8332
8333        '''
8334        self.port_override = port_override if port_override is not None else 0
8335        '''
8336
8337        '''
8338        self.replica_set = replica_set if replica_set is not None else ''
8339        '''
8340
8341        '''
8342        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8343        '''
8344         ID of the secret store containing credentials for this resource, if any.
8345        '''
8346        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8347        '''
8348         Tags is a map of key, value pairs.
8349        '''
8350        self.tls_required = tls_required if tls_required is not None else False
8351        '''
8352
8353        '''
8354        self.username = username if username is not None else ''
8355        '''
8356
8357        '''
8358
8359    def __repr__(self):
8360        return '<sdm.MongoReplicaSet ' + \
8361            'auth_database: ' + repr(self.auth_database) + ' ' +\
8362            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8363            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
8364            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8365            'healthy: ' + repr(self.healthy) + ' ' +\
8366            'hostname: ' + repr(self.hostname) + ' ' +\
8367            'id: ' + repr(self.id) + ' ' +\
8368            'name: ' + repr(self.name) + ' ' +\
8369            'password: ' + repr(self.password) + ' ' +\
8370            'port: ' + repr(self.port) + ' ' +\
8371            'port_override: ' + repr(self.port_override) + ' ' +\
8372            'replica_set: ' + repr(self.replica_set) + ' ' +\
8373            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8374            'tags: ' + repr(self.tags) + ' ' +\
8375            'tls_required: ' + repr(self.tls_required) + ' ' +\
8376            'username: ' + repr(self.username) + ' ' +\
8377            '>'
8378
8379    def to_dict(self):
8380        return {
8381            'auth_database': self.auth_database,
8382            'bind_interface': self.bind_interface,
8383            'connect_to_replica': self.connect_to_replica,
8384            'egress_filter': self.egress_filter,
8385            'healthy': self.healthy,
8386            'hostname': self.hostname,
8387            'id': self.id,
8388            'name': self.name,
8389            'password': self.password,
8390            'port': self.port,
8391            'port_override': self.port_override,
8392            'replica_set': self.replica_set,
8393            'secret_store_id': self.secret_store_id,
8394            'tags': self.tags,
8395            'tls_required': self.tls_required,
8396            'username': self.username,
8397        }
8398
8399    @classmethod
8400    def from_dict(cls, d):
8401        return cls(
8402            auth_database=d.get('auth_database'),
8403            bind_interface=d.get('bind_interface'),
8404            connect_to_replica=d.get('connect_to_replica'),
8405            egress_filter=d.get('egress_filter'),
8406            healthy=d.get('healthy'),
8407            hostname=d.get('hostname'),
8408            id=d.get('id'),
8409            name=d.get('name'),
8410            password=d.get('password'),
8411            port=d.get('port'),
8412            port_override=d.get('port_override'),
8413            replica_set=d.get('replica_set'),
8414            secret_store_id=d.get('secret_store_id'),
8415            tags=d.get('tags'),
8416            tls_required=d.get('tls_required'),
8417            username=d.get('username'),
8418        )
MongoReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8275    def __init__(
8276        self,
8277        auth_database=None,
8278        bind_interface=None,
8279        connect_to_replica=None,
8280        egress_filter=None,
8281        healthy=None,
8282        hostname=None,
8283        id=None,
8284        name=None,
8285        password=None,
8286        port=None,
8287        port_override=None,
8288        replica_set=None,
8289        secret_store_id=None,
8290        tags=None,
8291        tls_required=None,
8292        username=None,
8293    ):
8294        self.auth_database = auth_database if auth_database is not None else ''
8295        '''
8296
8297        '''
8298        self.bind_interface = bind_interface if bind_interface is not None else ''
8299        '''
8300         Bind interface
8301        '''
8302        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
8303        '''
8304
8305        '''
8306        self.egress_filter = egress_filter if egress_filter is not None else ''
8307        '''
8308         A filter applied to the routing logic to pin datasource to nodes.
8309        '''
8310        self.healthy = healthy if healthy is not None else False
8311        '''
8312         True if the datasource is reachable and the credentials are valid.
8313        '''
8314        self.hostname = hostname if hostname is not None else ''
8315        '''
8316
8317        '''
8318        self.id = id if id is not None else ''
8319        '''
8320         Unique identifier of the Resource.
8321        '''
8322        self.name = name if name is not None else ''
8323        '''
8324         Unique human-readable name of the Resource.
8325        '''
8326        self.password = password if password is not None else ''
8327        '''
8328
8329        '''
8330        self.port = port if port is not None else 0
8331        '''
8332
8333        '''
8334        self.port_override = port_override if port_override is not None else 0
8335        '''
8336
8337        '''
8338        self.replica_set = replica_set if replica_set is not None else ''
8339        '''
8340
8341        '''
8342        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8343        '''
8344         ID of the secret store containing credentials for this resource, if any.
8345        '''
8346        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8347        '''
8348         Tags is a map of key, value pairs.
8349        '''
8350        self.tls_required = tls_required if tls_required is not None else False
8351        '''
8352
8353        '''
8354        self.username = username if username is not None else ''
8355        '''
8356
8357        '''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8379    def to_dict(self):
8380        return {
8381            'auth_database': self.auth_database,
8382            'bind_interface': self.bind_interface,
8383            'connect_to_replica': self.connect_to_replica,
8384            'egress_filter': self.egress_filter,
8385            'healthy': self.healthy,
8386            'hostname': self.hostname,
8387            'id': self.id,
8388            'name': self.name,
8389            'password': self.password,
8390            'port': self.port,
8391            'port_override': self.port_override,
8392            'replica_set': self.replica_set,
8393            'secret_store_id': self.secret_store_id,
8394            'tags': self.tags,
8395            'tls_required': self.tls_required,
8396            'username': self.username,
8397        }
@classmethod
def from_dict(cls, d)
8399    @classmethod
8400    def from_dict(cls, d):
8401        return cls(
8402            auth_database=d.get('auth_database'),
8403            bind_interface=d.get('bind_interface'),
8404            connect_to_replica=d.get('connect_to_replica'),
8405            egress_filter=d.get('egress_filter'),
8406            healthy=d.get('healthy'),
8407            hostname=d.get('hostname'),
8408            id=d.get('id'),
8409            name=d.get('name'),
8410            password=d.get('password'),
8411            port=d.get('port'),
8412            port_override=d.get('port_override'),
8413            replica_set=d.get('replica_set'),
8414            secret_store_id=d.get('secret_store_id'),
8415            tags=d.get('tags'),
8416            tls_required=d.get('tls_required'),
8417            username=d.get('username'),
8418        )
class MongoShardedCluster:
8421class MongoShardedCluster:
8422    '''
8423
8424    '''
8425    __slots__ = [
8426        'auth_database',
8427        'bind_interface',
8428        'egress_filter',
8429        'healthy',
8430        'hostname',
8431        'id',
8432        'name',
8433        'password',
8434        'port_override',
8435        'secret_store_id',
8436        'tags',
8437        'tls_required',
8438        'username',
8439    ]
8440
8441    def __init__(
8442        self,
8443        auth_database=None,
8444        bind_interface=None,
8445        egress_filter=None,
8446        healthy=None,
8447        hostname=None,
8448        id=None,
8449        name=None,
8450        password=None,
8451        port_override=None,
8452        secret_store_id=None,
8453        tags=None,
8454        tls_required=None,
8455        username=None,
8456    ):
8457        self.auth_database = auth_database if auth_database is not None else ''
8458        '''
8459
8460        '''
8461        self.bind_interface = bind_interface if bind_interface is not None else ''
8462        '''
8463         Bind interface
8464        '''
8465        self.egress_filter = egress_filter if egress_filter is not None else ''
8466        '''
8467         A filter applied to the routing logic to pin datasource to nodes.
8468        '''
8469        self.healthy = healthy if healthy is not None else False
8470        '''
8471         True if the datasource is reachable and the credentials are valid.
8472        '''
8473        self.hostname = hostname if hostname is not None else ''
8474        '''
8475
8476        '''
8477        self.id = id if id is not None else ''
8478        '''
8479         Unique identifier of the Resource.
8480        '''
8481        self.name = name if name is not None else ''
8482        '''
8483         Unique human-readable name of the Resource.
8484        '''
8485        self.password = password if password is not None else ''
8486        '''
8487
8488        '''
8489        self.port_override = port_override if port_override is not None else 0
8490        '''
8491
8492        '''
8493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8494        '''
8495         ID of the secret store containing credentials for this resource, if any.
8496        '''
8497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8498        '''
8499         Tags is a map of key, value pairs.
8500        '''
8501        self.tls_required = tls_required if tls_required is not None else False
8502        '''
8503
8504        '''
8505        self.username = username if username is not None else ''
8506        '''
8507
8508        '''
8509
8510    def __repr__(self):
8511        return '<sdm.MongoShardedCluster ' + \
8512            'auth_database: ' + repr(self.auth_database) + ' ' +\
8513            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8514            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8515            'healthy: ' + repr(self.healthy) + ' ' +\
8516            'hostname: ' + repr(self.hostname) + ' ' +\
8517            'id: ' + repr(self.id) + ' ' +\
8518            'name: ' + repr(self.name) + ' ' +\
8519            'password: ' + repr(self.password) + ' ' +\
8520            'port_override: ' + repr(self.port_override) + ' ' +\
8521            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8522            'tags: ' + repr(self.tags) + ' ' +\
8523            'tls_required: ' + repr(self.tls_required) + ' ' +\
8524            'username: ' + repr(self.username) + ' ' +\
8525            '>'
8526
8527    def to_dict(self):
8528        return {
8529            'auth_database': self.auth_database,
8530            'bind_interface': self.bind_interface,
8531            'egress_filter': self.egress_filter,
8532            'healthy': self.healthy,
8533            'hostname': self.hostname,
8534            'id': self.id,
8535            'name': self.name,
8536            'password': self.password,
8537            'port_override': self.port_override,
8538            'secret_store_id': self.secret_store_id,
8539            'tags': self.tags,
8540            'tls_required': self.tls_required,
8541            'username': self.username,
8542        }
8543
8544    @classmethod
8545    def from_dict(cls, d):
8546        return cls(
8547            auth_database=d.get('auth_database'),
8548            bind_interface=d.get('bind_interface'),
8549            egress_filter=d.get('egress_filter'),
8550            healthy=d.get('healthy'),
8551            hostname=d.get('hostname'),
8552            id=d.get('id'),
8553            name=d.get('name'),
8554            password=d.get('password'),
8555            port_override=d.get('port_override'),
8556            secret_store_id=d.get('secret_store_id'),
8557            tags=d.get('tags'),
8558            tls_required=d.get('tls_required'),
8559            username=d.get('username'),
8560        )
MongoShardedCluster( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8441    def __init__(
8442        self,
8443        auth_database=None,
8444        bind_interface=None,
8445        egress_filter=None,
8446        healthy=None,
8447        hostname=None,
8448        id=None,
8449        name=None,
8450        password=None,
8451        port_override=None,
8452        secret_store_id=None,
8453        tags=None,
8454        tls_required=None,
8455        username=None,
8456    ):
8457        self.auth_database = auth_database if auth_database is not None else ''
8458        '''
8459
8460        '''
8461        self.bind_interface = bind_interface if bind_interface is not None else ''
8462        '''
8463         Bind interface
8464        '''
8465        self.egress_filter = egress_filter if egress_filter is not None else ''
8466        '''
8467         A filter applied to the routing logic to pin datasource to nodes.
8468        '''
8469        self.healthy = healthy if healthy is not None else False
8470        '''
8471         True if the datasource is reachable and the credentials are valid.
8472        '''
8473        self.hostname = hostname if hostname is not None else ''
8474        '''
8475
8476        '''
8477        self.id = id if id is not None else ''
8478        '''
8479         Unique identifier of the Resource.
8480        '''
8481        self.name = name if name is not None else ''
8482        '''
8483         Unique human-readable name of the Resource.
8484        '''
8485        self.password = password if password is not None else ''
8486        '''
8487
8488        '''
8489        self.port_override = port_override if port_override is not None else 0
8490        '''
8491
8492        '''
8493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8494        '''
8495         ID of the secret store containing credentials for this resource, if any.
8496        '''
8497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8498        '''
8499         Tags is a map of key, value pairs.
8500        '''
8501        self.tls_required = tls_required if tls_required is not None else False
8502        '''
8503
8504        '''
8505        self.username = username if username is not None else ''
8506        '''
8507
8508        '''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8527    def to_dict(self):
8528        return {
8529            'auth_database': self.auth_database,
8530            'bind_interface': self.bind_interface,
8531            'egress_filter': self.egress_filter,
8532            'healthy': self.healthy,
8533            'hostname': self.hostname,
8534            'id': self.id,
8535            'name': self.name,
8536            'password': self.password,
8537            'port_override': self.port_override,
8538            'secret_store_id': self.secret_store_id,
8539            'tags': self.tags,
8540            'tls_required': self.tls_required,
8541            'username': self.username,
8542        }
@classmethod
def from_dict(cls, d)
8544    @classmethod
8545    def from_dict(cls, d):
8546        return cls(
8547            auth_database=d.get('auth_database'),
8548            bind_interface=d.get('bind_interface'),
8549            egress_filter=d.get('egress_filter'),
8550            healthy=d.get('healthy'),
8551            hostname=d.get('hostname'),
8552            id=d.get('id'),
8553            name=d.get('name'),
8554            password=d.get('password'),
8555            port_override=d.get('port_override'),
8556            secret_store_id=d.get('secret_store_id'),
8557            tags=d.get('tags'),
8558            tls_required=d.get('tls_required'),
8559            username=d.get('username'),
8560        )
class Mysql:
8563class Mysql:
8564    '''
8565
8566    '''
8567    __slots__ = [
8568        'bind_interface',
8569        'database',
8570        'egress_filter',
8571        'healthy',
8572        'hostname',
8573        'id',
8574        'name',
8575        'password',
8576        'port',
8577        'port_override',
8578        'secret_store_id',
8579        'tags',
8580        'username',
8581    ]
8582
8583    def __init__(
8584        self,
8585        bind_interface=None,
8586        database=None,
8587        egress_filter=None,
8588        healthy=None,
8589        hostname=None,
8590        id=None,
8591        name=None,
8592        password=None,
8593        port=None,
8594        port_override=None,
8595        secret_store_id=None,
8596        tags=None,
8597        username=None,
8598    ):
8599        self.bind_interface = bind_interface if bind_interface is not None else ''
8600        '''
8601         Bind interface
8602        '''
8603        self.database = database if database is not None else ''
8604        '''
8605
8606        '''
8607        self.egress_filter = egress_filter if egress_filter is not None else ''
8608        '''
8609         A filter applied to the routing logic to pin datasource to nodes.
8610        '''
8611        self.healthy = healthy if healthy is not None else False
8612        '''
8613         True if the datasource is reachable and the credentials are valid.
8614        '''
8615        self.hostname = hostname if hostname is not None else ''
8616        '''
8617
8618        '''
8619        self.id = id if id is not None else ''
8620        '''
8621         Unique identifier of the Resource.
8622        '''
8623        self.name = name if name is not None else ''
8624        '''
8625         Unique human-readable name of the Resource.
8626        '''
8627        self.password = password if password is not None else ''
8628        '''
8629
8630        '''
8631        self.port = port if port is not None else 0
8632        '''
8633
8634        '''
8635        self.port_override = port_override if port_override is not None else 0
8636        '''
8637
8638        '''
8639        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8640        '''
8641         ID of the secret store containing credentials for this resource, if any.
8642        '''
8643        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8644        '''
8645         Tags is a map of key, value pairs.
8646        '''
8647        self.username = username if username is not None else ''
8648        '''
8649
8650        '''
8651
8652    def __repr__(self):
8653        return '<sdm.Mysql ' + \
8654            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8655            'database: ' + repr(self.database) + ' ' +\
8656            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8657            'healthy: ' + repr(self.healthy) + ' ' +\
8658            'hostname: ' + repr(self.hostname) + ' ' +\
8659            'id: ' + repr(self.id) + ' ' +\
8660            'name: ' + repr(self.name) + ' ' +\
8661            'password: ' + repr(self.password) + ' ' +\
8662            'port: ' + repr(self.port) + ' ' +\
8663            'port_override: ' + repr(self.port_override) + ' ' +\
8664            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8665            'tags: ' + repr(self.tags) + ' ' +\
8666            'username: ' + repr(self.username) + ' ' +\
8667            '>'
8668
8669    def to_dict(self):
8670        return {
8671            'bind_interface': self.bind_interface,
8672            'database': self.database,
8673            'egress_filter': self.egress_filter,
8674            'healthy': self.healthy,
8675            'hostname': self.hostname,
8676            'id': self.id,
8677            'name': self.name,
8678            'password': self.password,
8679            'port': self.port,
8680            'port_override': self.port_override,
8681            'secret_store_id': self.secret_store_id,
8682            'tags': self.tags,
8683            'username': self.username,
8684        }
8685
8686    @classmethod
8687    def from_dict(cls, d):
8688        return cls(
8689            bind_interface=d.get('bind_interface'),
8690            database=d.get('database'),
8691            egress_filter=d.get('egress_filter'),
8692            healthy=d.get('healthy'),
8693            hostname=d.get('hostname'),
8694            id=d.get('id'),
8695            name=d.get('name'),
8696            password=d.get('password'),
8697            port=d.get('port'),
8698            port_override=d.get('port_override'),
8699            secret_store_id=d.get('secret_store_id'),
8700            tags=d.get('tags'),
8701            username=d.get('username'),
8702        )
Mysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
8583    def __init__(
8584        self,
8585        bind_interface=None,
8586        database=None,
8587        egress_filter=None,
8588        healthy=None,
8589        hostname=None,
8590        id=None,
8591        name=None,
8592        password=None,
8593        port=None,
8594        port_override=None,
8595        secret_store_id=None,
8596        tags=None,
8597        username=None,
8598    ):
8599        self.bind_interface = bind_interface if bind_interface is not None else ''
8600        '''
8601         Bind interface
8602        '''
8603        self.database = database if database is not None else ''
8604        '''
8605
8606        '''
8607        self.egress_filter = egress_filter if egress_filter is not None else ''
8608        '''
8609         A filter applied to the routing logic to pin datasource to nodes.
8610        '''
8611        self.healthy = healthy if healthy is not None else False
8612        '''
8613         True if the datasource is reachable and the credentials are valid.
8614        '''
8615        self.hostname = hostname if hostname is not None else ''
8616        '''
8617
8618        '''
8619        self.id = id if id is not None else ''
8620        '''
8621         Unique identifier of the Resource.
8622        '''
8623        self.name = name if name is not None else ''
8624        '''
8625         Unique human-readable name of the Resource.
8626        '''
8627        self.password = password if password is not None else ''
8628        '''
8629
8630        '''
8631        self.port = port if port is not None else 0
8632        '''
8633
8634        '''
8635        self.port_override = port_override if port_override is not None else 0
8636        '''
8637
8638        '''
8639        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8640        '''
8641         ID of the secret store containing credentials for this resource, if any.
8642        '''
8643        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8644        '''
8645         Tags is a map of key, value pairs.
8646        '''
8647        self.username = username if username is not None else ''
8648        '''
8649
8650        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
8669    def to_dict(self):
8670        return {
8671            'bind_interface': self.bind_interface,
8672            'database': self.database,
8673            'egress_filter': self.egress_filter,
8674            'healthy': self.healthy,
8675            'hostname': self.hostname,
8676            'id': self.id,
8677            'name': self.name,
8678            'password': self.password,
8679            'port': self.port,
8680            'port_override': self.port_override,
8681            'secret_store_id': self.secret_store_id,
8682            'tags': self.tags,
8683            'username': self.username,
8684        }
@classmethod
def from_dict(cls, d)
8686    @classmethod
8687    def from_dict(cls, d):
8688        return cls(
8689            bind_interface=d.get('bind_interface'),
8690            database=d.get('database'),
8691            egress_filter=d.get('egress_filter'),
8692            healthy=d.get('healthy'),
8693            hostname=d.get('hostname'),
8694            id=d.get('id'),
8695            name=d.get('name'),
8696            password=d.get('password'),
8697            port=d.get('port'),
8698            port_override=d.get('port_override'),
8699            secret_store_id=d.get('secret_store_id'),
8700            tags=d.get('tags'),
8701            username=d.get('username'),
8702        )
class Neptune:
8705class Neptune:
8706    '''
8707
8708    '''
8709    __slots__ = [
8710        'bind_interface',
8711        'egress_filter',
8712        'endpoint',
8713        'healthy',
8714        'id',
8715        'name',
8716        'port',
8717        'port_override',
8718        'secret_store_id',
8719        'tags',
8720    ]
8721
8722    def __init__(
8723        self,
8724        bind_interface=None,
8725        egress_filter=None,
8726        endpoint=None,
8727        healthy=None,
8728        id=None,
8729        name=None,
8730        port=None,
8731        port_override=None,
8732        secret_store_id=None,
8733        tags=None,
8734    ):
8735        self.bind_interface = bind_interface if bind_interface is not None else ''
8736        '''
8737         Bind interface
8738        '''
8739        self.egress_filter = egress_filter if egress_filter is not None else ''
8740        '''
8741         A filter applied to the routing logic to pin datasource to nodes.
8742        '''
8743        self.endpoint = endpoint if endpoint is not None else ''
8744        '''
8745
8746        '''
8747        self.healthy = healthy if healthy is not None else False
8748        '''
8749         True if the datasource is reachable and the credentials are valid.
8750        '''
8751        self.id = id if id is not None else ''
8752        '''
8753         Unique identifier of the Resource.
8754        '''
8755        self.name = name if name is not None else ''
8756        '''
8757         Unique human-readable name of the Resource.
8758        '''
8759        self.port = port if port is not None else 0
8760        '''
8761
8762        '''
8763        self.port_override = port_override if port_override is not None else 0
8764        '''
8765
8766        '''
8767        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8768        '''
8769         ID of the secret store containing credentials for this resource, if any.
8770        '''
8771        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8772        '''
8773         Tags is a map of key, value pairs.
8774        '''
8775
8776    def __repr__(self):
8777        return '<sdm.Neptune ' + \
8778            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8779            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8780            'endpoint: ' + repr(self.endpoint) + ' ' +\
8781            'healthy: ' + repr(self.healthy) + ' ' +\
8782            'id: ' + repr(self.id) + ' ' +\
8783            'name: ' + repr(self.name) + ' ' +\
8784            'port: ' + repr(self.port) + ' ' +\
8785            'port_override: ' + repr(self.port_override) + ' ' +\
8786            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8787            'tags: ' + repr(self.tags) + ' ' +\
8788            '>'
8789
8790    def to_dict(self):
8791        return {
8792            'bind_interface': self.bind_interface,
8793            'egress_filter': self.egress_filter,
8794            'endpoint': self.endpoint,
8795            'healthy': self.healthy,
8796            'id': self.id,
8797            'name': self.name,
8798            'port': self.port,
8799            'port_override': self.port_override,
8800            'secret_store_id': self.secret_store_id,
8801            'tags': self.tags,
8802        }
8803
8804    @classmethod
8805    def from_dict(cls, d):
8806        return cls(
8807            bind_interface=d.get('bind_interface'),
8808            egress_filter=d.get('egress_filter'),
8809            endpoint=d.get('endpoint'),
8810            healthy=d.get('healthy'),
8811            id=d.get('id'),
8812            name=d.get('name'),
8813            port=d.get('port'),
8814            port_override=d.get('port_override'),
8815            secret_store_id=d.get('secret_store_id'),
8816            tags=d.get('tags'),
8817        )
Neptune( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
8722    def __init__(
8723        self,
8724        bind_interface=None,
8725        egress_filter=None,
8726        endpoint=None,
8727        healthy=None,
8728        id=None,
8729        name=None,
8730        port=None,
8731        port_override=None,
8732        secret_store_id=None,
8733        tags=None,
8734    ):
8735        self.bind_interface = bind_interface if bind_interface is not None else ''
8736        '''
8737         Bind interface
8738        '''
8739        self.egress_filter = egress_filter if egress_filter is not None else ''
8740        '''
8741         A filter applied to the routing logic to pin datasource to nodes.
8742        '''
8743        self.endpoint = endpoint if endpoint is not None else ''
8744        '''
8745
8746        '''
8747        self.healthy = healthy if healthy is not None else False
8748        '''
8749         True if the datasource is reachable and the credentials are valid.
8750        '''
8751        self.id = id if id is not None else ''
8752        '''
8753         Unique identifier of the Resource.
8754        '''
8755        self.name = name if name is not None else ''
8756        '''
8757         Unique human-readable name of the Resource.
8758        '''
8759        self.port = port if port is not None else 0
8760        '''
8761
8762        '''
8763        self.port_override = port_override if port_override is not None else 0
8764        '''
8765
8766        '''
8767        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8768        '''
8769         ID of the secret store containing credentials for this resource, if any.
8770        '''
8771        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8772        '''
8773         Tags is a map of key, value pairs.
8774        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
8790    def to_dict(self):
8791        return {
8792            'bind_interface': self.bind_interface,
8793            'egress_filter': self.egress_filter,
8794            'endpoint': self.endpoint,
8795            'healthy': self.healthy,
8796            'id': self.id,
8797            'name': self.name,
8798            'port': self.port,
8799            'port_override': self.port_override,
8800            'secret_store_id': self.secret_store_id,
8801            'tags': self.tags,
8802        }
@classmethod
def from_dict(cls, d)
8804    @classmethod
8805    def from_dict(cls, d):
8806        return cls(
8807            bind_interface=d.get('bind_interface'),
8808            egress_filter=d.get('egress_filter'),
8809            endpoint=d.get('endpoint'),
8810            healthy=d.get('healthy'),
8811            id=d.get('id'),
8812            name=d.get('name'),
8813            port=d.get('port'),
8814            port_override=d.get('port_override'),
8815            secret_store_id=d.get('secret_store_id'),
8816            tags=d.get('tags'),
8817        )
class NeptuneIAM:
8820class NeptuneIAM:
8821    '''
8822
8823    '''
8824    __slots__ = [
8825        'access_key',
8826        'bind_interface',
8827        'egress_filter',
8828        'endpoint',
8829        'healthy',
8830        'id',
8831        'name',
8832        'port',
8833        'port_override',
8834        'region',
8835        'role_arn',
8836        'role_external_id',
8837        'secret_access_key',
8838        'secret_store_id',
8839        'tags',
8840    ]
8841
8842    def __init__(
8843        self,
8844        access_key=None,
8845        bind_interface=None,
8846        egress_filter=None,
8847        endpoint=None,
8848        healthy=None,
8849        id=None,
8850        name=None,
8851        port=None,
8852        port_override=None,
8853        region=None,
8854        role_arn=None,
8855        role_external_id=None,
8856        secret_access_key=None,
8857        secret_store_id=None,
8858        tags=None,
8859    ):
8860        self.access_key = access_key if access_key is not None else ''
8861        '''
8862
8863        '''
8864        self.bind_interface = bind_interface if bind_interface is not None else ''
8865        '''
8866         Bind interface
8867        '''
8868        self.egress_filter = egress_filter if egress_filter is not None else ''
8869        '''
8870         A filter applied to the routing logic to pin datasource to nodes.
8871        '''
8872        self.endpoint = endpoint if endpoint is not None else ''
8873        '''
8874
8875        '''
8876        self.healthy = healthy if healthy is not None else False
8877        '''
8878         True if the datasource is reachable and the credentials are valid.
8879        '''
8880        self.id = id if id is not None else ''
8881        '''
8882         Unique identifier of the Resource.
8883        '''
8884        self.name = name if name is not None else ''
8885        '''
8886         Unique human-readable name of the Resource.
8887        '''
8888        self.port = port if port is not None else 0
8889        '''
8890
8891        '''
8892        self.port_override = port_override if port_override is not None else 0
8893        '''
8894
8895        '''
8896        self.region = region if region is not None else ''
8897        '''
8898
8899        '''
8900        self.role_arn = role_arn if role_arn is not None else ''
8901        '''
8902
8903        '''
8904        self.role_external_id = role_external_id if role_external_id is not None else ''
8905        '''
8906
8907        '''
8908        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
8909        '''
8910
8911        '''
8912        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8913        '''
8914         ID of the secret store containing credentials for this resource, if any.
8915        '''
8916        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8917        '''
8918         Tags is a map of key, value pairs.
8919        '''
8920
8921    def __repr__(self):
8922        return '<sdm.NeptuneIAM ' + \
8923            'access_key: ' + repr(self.access_key) + ' ' +\
8924            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8925            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8926            'endpoint: ' + repr(self.endpoint) + ' ' +\
8927            'healthy: ' + repr(self.healthy) + ' ' +\
8928            'id: ' + repr(self.id) + ' ' +\
8929            'name: ' + repr(self.name) + ' ' +\
8930            'port: ' + repr(self.port) + ' ' +\
8931            'port_override: ' + repr(self.port_override) + ' ' +\
8932            'region: ' + repr(self.region) + ' ' +\
8933            'role_arn: ' + repr(self.role_arn) + ' ' +\
8934            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
8935            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
8936            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8937            'tags: ' + repr(self.tags) + ' ' +\
8938            '>'
8939
8940    def to_dict(self):
8941        return {
8942            'access_key': self.access_key,
8943            'bind_interface': self.bind_interface,
8944            'egress_filter': self.egress_filter,
8945            'endpoint': self.endpoint,
8946            'healthy': self.healthy,
8947            'id': self.id,
8948            'name': self.name,
8949            'port': self.port,
8950            'port_override': self.port_override,
8951            'region': self.region,
8952            'role_arn': self.role_arn,
8953            'role_external_id': self.role_external_id,
8954            'secret_access_key': self.secret_access_key,
8955            'secret_store_id': self.secret_store_id,
8956            'tags': self.tags,
8957        }
8958
8959    @classmethod
8960    def from_dict(cls, d):
8961        return cls(
8962            access_key=d.get('access_key'),
8963            bind_interface=d.get('bind_interface'),
8964            egress_filter=d.get('egress_filter'),
8965            endpoint=d.get('endpoint'),
8966            healthy=d.get('healthy'),
8967            id=d.get('id'),
8968            name=d.get('name'),
8969            port=d.get('port'),
8970            port_override=d.get('port_override'),
8971            region=d.get('region'),
8972            role_arn=d.get('role_arn'),
8973            role_external_id=d.get('role_external_id'),
8974            secret_access_key=d.get('secret_access_key'),
8975            secret_store_id=d.get('secret_store_id'),
8976            tags=d.get('tags'),
8977        )
NeptuneIAM( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
8842    def __init__(
8843        self,
8844        access_key=None,
8845        bind_interface=None,
8846        egress_filter=None,
8847        endpoint=None,
8848        healthy=None,
8849        id=None,
8850        name=None,
8851        port=None,
8852        port_override=None,
8853        region=None,
8854        role_arn=None,
8855        role_external_id=None,
8856        secret_access_key=None,
8857        secret_store_id=None,
8858        tags=None,
8859    ):
8860        self.access_key = access_key if access_key is not None else ''
8861        '''
8862
8863        '''
8864        self.bind_interface = bind_interface if bind_interface is not None else ''
8865        '''
8866         Bind interface
8867        '''
8868        self.egress_filter = egress_filter if egress_filter is not None else ''
8869        '''
8870         A filter applied to the routing logic to pin datasource to nodes.
8871        '''
8872        self.endpoint = endpoint if endpoint is not None else ''
8873        '''
8874
8875        '''
8876        self.healthy = healthy if healthy is not None else False
8877        '''
8878         True if the datasource is reachable and the credentials are valid.
8879        '''
8880        self.id = id if id is not None else ''
8881        '''
8882         Unique identifier of the Resource.
8883        '''
8884        self.name = name if name is not None else ''
8885        '''
8886         Unique human-readable name of the Resource.
8887        '''
8888        self.port = port if port is not None else 0
8889        '''
8890
8891        '''
8892        self.port_override = port_override if port_override is not None else 0
8893        '''
8894
8895        '''
8896        self.region = region if region is not None else ''
8897        '''
8898
8899        '''
8900        self.role_arn = role_arn if role_arn is not None else ''
8901        '''
8902
8903        '''
8904        self.role_external_id = role_external_id if role_external_id is not None else ''
8905        '''
8906
8907        '''
8908        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
8909        '''
8910
8911        '''
8912        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8913        '''
8914         ID of the secret store containing credentials for this resource, if any.
8915        '''
8916        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8917        '''
8918         Tags is a map of key, value pairs.
8919        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
8940    def to_dict(self):
8941        return {
8942            'access_key': self.access_key,
8943            'bind_interface': self.bind_interface,
8944            'egress_filter': self.egress_filter,
8945            'endpoint': self.endpoint,
8946            'healthy': self.healthy,
8947            'id': self.id,
8948            'name': self.name,
8949            'port': self.port,
8950            'port_override': self.port_override,
8951            'region': self.region,
8952            'role_arn': self.role_arn,
8953            'role_external_id': self.role_external_id,
8954            'secret_access_key': self.secret_access_key,
8955            'secret_store_id': self.secret_store_id,
8956            'tags': self.tags,
8957        }
@classmethod
def from_dict(cls, d)
8959    @classmethod
8960    def from_dict(cls, d):
8961        return cls(
8962            access_key=d.get('access_key'),
8963            bind_interface=d.get('bind_interface'),
8964            egress_filter=d.get('egress_filter'),
8965            endpoint=d.get('endpoint'),
8966            healthy=d.get('healthy'),
8967            id=d.get('id'),
8968            name=d.get('name'),
8969            port=d.get('port'),
8970            port_override=d.get('port_override'),
8971            region=d.get('region'),
8972            role_arn=d.get('role_arn'),
8973            role_external_id=d.get('role_external_id'),
8974            secret_access_key=d.get('secret_access_key'),
8975            secret_store_id=d.get('secret_store_id'),
8976            tags=d.get('tags'),
8977        )
class NodeCreateResponse:
8980class NodeCreateResponse:
8981    '''
8982     NodeCreateResponse reports how the Nodes were created in the system.
8983    '''
8984    __slots__ = [
8985        'meta',
8986        'node',
8987        'rate_limit',
8988        'token',
8989    ]
8990
8991    def __init__(
8992        self,
8993        meta=None,
8994        node=None,
8995        rate_limit=None,
8996        token=None,
8997    ):
8998        self.meta = meta if meta is not None else None
8999        '''
9000         Reserved for future use.
9001        '''
9002        self.node = node if node is not None else None
9003        '''
9004         The created Node.
9005        '''
9006        self.rate_limit = rate_limit if rate_limit is not None else None
9007        '''
9008         Rate limit information.
9009        '''
9010        self.token = token if token is not None else ''
9011        '''
9012         The auth token generated for the Node. The Node will use this token to
9013         authenticate with the strongDM API.
9014        '''
9015
9016    def __repr__(self):
9017        return '<sdm.NodeCreateResponse ' + \
9018            'meta: ' + repr(self.meta) + ' ' +\
9019            'node: ' + repr(self.node) + ' ' +\
9020            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9021            'token: ' + repr(self.token) + ' ' +\
9022            '>'
9023
9024    def to_dict(self):
9025        return {
9026            'meta': self.meta,
9027            'node': self.node,
9028            'rate_limit': self.rate_limit,
9029            'token': self.token,
9030        }
9031
9032    @classmethod
9033    def from_dict(cls, d):
9034        return cls(
9035            meta=d.get('meta'),
9036            node=d.get('node'),
9037            rate_limit=d.get('rate_limit'),
9038            token=d.get('token'),
9039        )

NodeCreateResponse reports how the Nodes were created in the system.

NodeCreateResponse(meta=None, node=None, rate_limit=None, token=None)
8991    def __init__(
8992        self,
8993        meta=None,
8994        node=None,
8995        rate_limit=None,
8996        token=None,
8997    ):
8998        self.meta = meta if meta is not None else None
8999        '''
9000         Reserved for future use.
9001        '''
9002        self.node = node if node is not None else None
9003        '''
9004         The created Node.
9005        '''
9006        self.rate_limit = rate_limit if rate_limit is not None else None
9007        '''
9008         Rate limit information.
9009        '''
9010        self.token = token if token is not None else ''
9011        '''
9012         The auth token generated for the Node. The Node will use this token to
9013         authenticate with the strongDM API.
9014        '''
meta

Reserved for future use.

node

The created Node.

rate_limit

Rate limit information.

token

The auth token generated for the Node. The Node will use this token to authenticate with the strongDM API.

def to_dict(self)
9024    def to_dict(self):
9025        return {
9026            'meta': self.meta,
9027            'node': self.node,
9028            'rate_limit': self.rate_limit,
9029            'token': self.token,
9030        }
@classmethod
def from_dict(cls, d)
9032    @classmethod
9033    def from_dict(cls, d):
9034        return cls(
9035            meta=d.get('meta'),
9036            node=d.get('node'),
9037            rate_limit=d.get('rate_limit'),
9038            token=d.get('token'),
9039        )
class NodeDeleteResponse:
9042class NodeDeleteResponse:
9043    '''
9044     NodeDeleteResponse returns information about a Node that was deleted.
9045    '''
9046    __slots__ = [
9047        'meta',
9048        'rate_limit',
9049    ]
9050
9051    def __init__(
9052        self,
9053        meta=None,
9054        rate_limit=None,
9055    ):
9056        self.meta = meta if meta is not None else None
9057        '''
9058         Reserved for future use.
9059        '''
9060        self.rate_limit = rate_limit if rate_limit is not None else None
9061        '''
9062         Rate limit information.
9063        '''
9064
9065    def __repr__(self):
9066        return '<sdm.NodeDeleteResponse ' + \
9067            'meta: ' + repr(self.meta) + ' ' +\
9068            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9069            '>'
9070
9071    def to_dict(self):
9072        return {
9073            'meta': self.meta,
9074            'rate_limit': self.rate_limit,
9075        }
9076
9077    @classmethod
9078    def from_dict(cls, d):
9079        return cls(
9080            meta=d.get('meta'),
9081            rate_limit=d.get('rate_limit'),
9082        )

NodeDeleteResponse returns information about a Node that was deleted.

NodeDeleteResponse(meta=None, rate_limit=None)
9051    def __init__(
9052        self,
9053        meta=None,
9054        rate_limit=None,
9055    ):
9056        self.meta = meta if meta is not None else None
9057        '''
9058         Reserved for future use.
9059        '''
9060        self.rate_limit = rate_limit if rate_limit is not None else None
9061        '''
9062         Rate limit information.
9063        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
9071    def to_dict(self):
9072        return {
9073            'meta': self.meta,
9074            'rate_limit': self.rate_limit,
9075        }
@classmethod
def from_dict(cls, d)
9077    @classmethod
9078    def from_dict(cls, d):
9079        return cls(
9080            meta=d.get('meta'),
9081            rate_limit=d.get('rate_limit'),
9082        )
class NodeGetResponse:
9085class NodeGetResponse:
9086    '''
9087     NodeGetResponse returns a requested Node.
9088    '''
9089    __slots__ = [
9090        'meta',
9091        'node',
9092        'rate_limit',
9093    ]
9094
9095    def __init__(
9096        self,
9097        meta=None,
9098        node=None,
9099        rate_limit=None,
9100    ):
9101        self.meta = meta if meta is not None else None
9102        '''
9103         Reserved for future use.
9104        '''
9105        self.node = node if node is not None else None
9106        '''
9107         The requested Node.
9108        '''
9109        self.rate_limit = rate_limit if rate_limit is not None else None
9110        '''
9111         Rate limit information.
9112        '''
9113
9114    def __repr__(self):
9115        return '<sdm.NodeGetResponse ' + \
9116            'meta: ' + repr(self.meta) + ' ' +\
9117            'node: ' + repr(self.node) + ' ' +\
9118            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9119            '>'
9120
9121    def to_dict(self):
9122        return {
9123            'meta': self.meta,
9124            'node': self.node,
9125            'rate_limit': self.rate_limit,
9126        }
9127
9128    @classmethod
9129    def from_dict(cls, d):
9130        return cls(
9131            meta=d.get('meta'),
9132            node=d.get('node'),
9133            rate_limit=d.get('rate_limit'),
9134        )

NodeGetResponse returns a requested Node.

NodeGetResponse(meta=None, node=None, rate_limit=None)
9095    def __init__(
9096        self,
9097        meta=None,
9098        node=None,
9099        rate_limit=None,
9100    ):
9101        self.meta = meta if meta is not None else None
9102        '''
9103         Reserved for future use.
9104        '''
9105        self.node = node if node is not None else None
9106        '''
9107         The requested Node.
9108        '''
9109        self.rate_limit = rate_limit if rate_limit is not None else None
9110        '''
9111         Rate limit information.
9112        '''
meta

Reserved for future use.

node

The requested Node.

rate_limit

Rate limit information.

def to_dict(self)
9121    def to_dict(self):
9122        return {
9123            'meta': self.meta,
9124            'node': self.node,
9125            'rate_limit': self.rate_limit,
9126        }
@classmethod
def from_dict(cls, d)
9128    @classmethod
9129    def from_dict(cls, d):
9130        return cls(
9131            meta=d.get('meta'),
9132            node=d.get('node'),
9133            rate_limit=d.get('rate_limit'),
9134        )
class NodeUpdateResponse:
9137class NodeUpdateResponse:
9138    '''
9139     NodeUpdateResponse returns the fields of a Node after it has been updated by
9140     a NodeUpdateRequest.
9141    '''
9142    __slots__ = [
9143        'meta',
9144        'node',
9145        'rate_limit',
9146    ]
9147
9148    def __init__(
9149        self,
9150        meta=None,
9151        node=None,
9152        rate_limit=None,
9153    ):
9154        self.meta = meta if meta is not None else None
9155        '''
9156         Reserved for future use.
9157        '''
9158        self.node = node if node is not None else None
9159        '''
9160         The updated Node.
9161        '''
9162        self.rate_limit = rate_limit if rate_limit is not None else None
9163        '''
9164         Rate limit information.
9165        '''
9166
9167    def __repr__(self):
9168        return '<sdm.NodeUpdateResponse ' + \
9169            'meta: ' + repr(self.meta) + ' ' +\
9170            'node: ' + repr(self.node) + ' ' +\
9171            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9172            '>'
9173
9174    def to_dict(self):
9175        return {
9176            'meta': self.meta,
9177            'node': self.node,
9178            'rate_limit': self.rate_limit,
9179        }
9180
9181    @classmethod
9182    def from_dict(cls, d):
9183        return cls(
9184            meta=d.get('meta'),
9185            node=d.get('node'),
9186            rate_limit=d.get('rate_limit'),
9187        )

NodeUpdateResponse returns the fields of a Node after it has been updated by a NodeUpdateRequest.

NodeUpdateResponse(meta=None, node=None, rate_limit=None)
9148    def __init__(
9149        self,
9150        meta=None,
9151        node=None,
9152        rate_limit=None,
9153    ):
9154        self.meta = meta if meta is not None else None
9155        '''
9156         Reserved for future use.
9157        '''
9158        self.node = node if node is not None else None
9159        '''
9160         The updated Node.
9161        '''
9162        self.rate_limit = rate_limit if rate_limit is not None else None
9163        '''
9164         Rate limit information.
9165        '''
meta

Reserved for future use.

node

The updated Node.

rate_limit

Rate limit information.

def to_dict(self)
9174    def to_dict(self):
9175        return {
9176            'meta': self.meta,
9177            'node': self.node,
9178            'rate_limit': self.rate_limit,
9179        }
@classmethod
def from_dict(cls, d)
9181    @classmethod
9182    def from_dict(cls, d):
9183        return cls(
9184            meta=d.get('meta'),
9185            node=d.get('node'),
9186            rate_limit=d.get('rate_limit'),
9187        )
class Oracle:
9190class Oracle:
9191    '''
9192
9193    '''
9194    __slots__ = [
9195        'bind_interface',
9196        'database',
9197        'egress_filter',
9198        'healthy',
9199        'hostname',
9200        'id',
9201        'name',
9202        'password',
9203        'port',
9204        'port_override',
9205        'secret_store_id',
9206        'tags',
9207        'tls_required',
9208        'username',
9209    ]
9210
9211    def __init__(
9212        self,
9213        bind_interface=None,
9214        database=None,
9215        egress_filter=None,
9216        healthy=None,
9217        hostname=None,
9218        id=None,
9219        name=None,
9220        password=None,
9221        port=None,
9222        port_override=None,
9223        secret_store_id=None,
9224        tags=None,
9225        tls_required=None,
9226        username=None,
9227    ):
9228        self.bind_interface = bind_interface if bind_interface is not None else ''
9229        '''
9230         Bind interface
9231        '''
9232        self.database = database if database is not None else ''
9233        '''
9234
9235        '''
9236        self.egress_filter = egress_filter if egress_filter is not None else ''
9237        '''
9238         A filter applied to the routing logic to pin datasource to nodes.
9239        '''
9240        self.healthy = healthy if healthy is not None else False
9241        '''
9242         True if the datasource is reachable and the credentials are valid.
9243        '''
9244        self.hostname = hostname if hostname is not None else ''
9245        '''
9246
9247        '''
9248        self.id = id if id is not None else ''
9249        '''
9250         Unique identifier of the Resource.
9251        '''
9252        self.name = name if name is not None else ''
9253        '''
9254         Unique human-readable name of the Resource.
9255        '''
9256        self.password = password if password is not None else ''
9257        '''
9258
9259        '''
9260        self.port = port if port is not None else 0
9261        '''
9262
9263        '''
9264        self.port_override = port_override if port_override is not None else 0
9265        '''
9266
9267        '''
9268        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9269        '''
9270         ID of the secret store containing credentials for this resource, if any.
9271        '''
9272        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9273        '''
9274         Tags is a map of key, value pairs.
9275        '''
9276        self.tls_required = tls_required if tls_required is not None else False
9277        '''
9278
9279        '''
9280        self.username = username if username is not None else ''
9281        '''
9282
9283        '''
9284
9285    def __repr__(self):
9286        return '<sdm.Oracle ' + \
9287            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9288            'database: ' + repr(self.database) + ' ' +\
9289            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9290            'healthy: ' + repr(self.healthy) + ' ' +\
9291            'hostname: ' + repr(self.hostname) + ' ' +\
9292            'id: ' + repr(self.id) + ' ' +\
9293            'name: ' + repr(self.name) + ' ' +\
9294            'password: ' + repr(self.password) + ' ' +\
9295            'port: ' + repr(self.port) + ' ' +\
9296            'port_override: ' + repr(self.port_override) + ' ' +\
9297            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9298            'tags: ' + repr(self.tags) + ' ' +\
9299            'tls_required: ' + repr(self.tls_required) + ' ' +\
9300            'username: ' + repr(self.username) + ' ' +\
9301            '>'
9302
9303    def to_dict(self):
9304        return {
9305            'bind_interface': self.bind_interface,
9306            'database': self.database,
9307            'egress_filter': self.egress_filter,
9308            'healthy': self.healthy,
9309            'hostname': self.hostname,
9310            'id': self.id,
9311            'name': self.name,
9312            'password': self.password,
9313            'port': self.port,
9314            'port_override': self.port_override,
9315            'secret_store_id': self.secret_store_id,
9316            'tags': self.tags,
9317            'tls_required': self.tls_required,
9318            'username': self.username,
9319        }
9320
9321    @classmethod
9322    def from_dict(cls, d):
9323        return cls(
9324            bind_interface=d.get('bind_interface'),
9325            database=d.get('database'),
9326            egress_filter=d.get('egress_filter'),
9327            healthy=d.get('healthy'),
9328            hostname=d.get('hostname'),
9329            id=d.get('id'),
9330            name=d.get('name'),
9331            password=d.get('password'),
9332            port=d.get('port'),
9333            port_override=d.get('port_override'),
9334            secret_store_id=d.get('secret_store_id'),
9335            tags=d.get('tags'),
9336            tls_required=d.get('tls_required'),
9337            username=d.get('username'),
9338        )
Oracle( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
9211    def __init__(
9212        self,
9213        bind_interface=None,
9214        database=None,
9215        egress_filter=None,
9216        healthy=None,
9217        hostname=None,
9218        id=None,
9219        name=None,
9220        password=None,
9221        port=None,
9222        port_override=None,
9223        secret_store_id=None,
9224        tags=None,
9225        tls_required=None,
9226        username=None,
9227    ):
9228        self.bind_interface = bind_interface if bind_interface is not None else ''
9229        '''
9230         Bind interface
9231        '''
9232        self.database = database if database is not None else ''
9233        '''
9234
9235        '''
9236        self.egress_filter = egress_filter if egress_filter is not None else ''
9237        '''
9238         A filter applied to the routing logic to pin datasource to nodes.
9239        '''
9240        self.healthy = healthy if healthy is not None else False
9241        '''
9242         True if the datasource is reachable and the credentials are valid.
9243        '''
9244        self.hostname = hostname if hostname is not None else ''
9245        '''
9246
9247        '''
9248        self.id = id if id is not None else ''
9249        '''
9250         Unique identifier of the Resource.
9251        '''
9252        self.name = name if name is not None else ''
9253        '''
9254         Unique human-readable name of the Resource.
9255        '''
9256        self.password = password if password is not None else ''
9257        '''
9258
9259        '''
9260        self.port = port if port is not None else 0
9261        '''
9262
9263        '''
9264        self.port_override = port_override if port_override is not None else 0
9265        '''
9266
9267        '''
9268        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9269        '''
9270         ID of the secret store containing credentials for this resource, if any.
9271        '''
9272        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9273        '''
9274         Tags is a map of key, value pairs.
9275        '''
9276        self.tls_required = tls_required if tls_required is not None else False
9277        '''
9278
9279        '''
9280        self.username = username if username is not None else ''
9281        '''
9282
9283        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9303    def to_dict(self):
9304        return {
9305            'bind_interface': self.bind_interface,
9306            'database': self.database,
9307            'egress_filter': self.egress_filter,
9308            'healthy': self.healthy,
9309            'hostname': self.hostname,
9310            'id': self.id,
9311            'name': self.name,
9312            'password': self.password,
9313            'port': self.port,
9314            'port_override': self.port_override,
9315            'secret_store_id': self.secret_store_id,
9316            'tags': self.tags,
9317            'tls_required': self.tls_required,
9318            'username': self.username,
9319        }
@classmethod
def from_dict(cls, d)
9321    @classmethod
9322    def from_dict(cls, d):
9323        return cls(
9324            bind_interface=d.get('bind_interface'),
9325            database=d.get('database'),
9326            egress_filter=d.get('egress_filter'),
9327            healthy=d.get('healthy'),
9328            hostname=d.get('hostname'),
9329            id=d.get('id'),
9330            name=d.get('name'),
9331            password=d.get('password'),
9332            port=d.get('port'),
9333            port_override=d.get('port_override'),
9334            secret_store_id=d.get('secret_store_id'),
9335            tags=d.get('tags'),
9336            tls_required=d.get('tls_required'),
9337            username=d.get('username'),
9338        )
class Postgres:
9341class Postgres:
9342    '''
9343
9344    '''
9345    __slots__ = [
9346        'bind_interface',
9347        'database',
9348        'egress_filter',
9349        'healthy',
9350        'hostname',
9351        'id',
9352        'name',
9353        'override_database',
9354        'password',
9355        'port',
9356        'port_override',
9357        'secret_store_id',
9358        'tags',
9359        'username',
9360    ]
9361
9362    def __init__(
9363        self,
9364        bind_interface=None,
9365        database=None,
9366        egress_filter=None,
9367        healthy=None,
9368        hostname=None,
9369        id=None,
9370        name=None,
9371        override_database=None,
9372        password=None,
9373        port=None,
9374        port_override=None,
9375        secret_store_id=None,
9376        tags=None,
9377        username=None,
9378    ):
9379        self.bind_interface = bind_interface if bind_interface is not None else ''
9380        '''
9381         Bind interface
9382        '''
9383        self.database = database if database is not None else ''
9384        '''
9385
9386        '''
9387        self.egress_filter = egress_filter if egress_filter is not None else ''
9388        '''
9389         A filter applied to the routing logic to pin datasource to nodes.
9390        '''
9391        self.healthy = healthy if healthy is not None else False
9392        '''
9393         True if the datasource is reachable and the credentials are valid.
9394        '''
9395        self.hostname = hostname if hostname is not None else ''
9396        '''
9397
9398        '''
9399        self.id = id if id is not None else ''
9400        '''
9401         Unique identifier of the Resource.
9402        '''
9403        self.name = name if name is not None else ''
9404        '''
9405         Unique human-readable name of the Resource.
9406        '''
9407        self.override_database = override_database if override_database is not None else False
9408        '''
9409
9410        '''
9411        self.password = password if password is not None else ''
9412        '''
9413
9414        '''
9415        self.port = port if port is not None else 0
9416        '''
9417
9418        '''
9419        self.port_override = port_override if port_override is not None else 0
9420        '''
9421
9422        '''
9423        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9424        '''
9425         ID of the secret store containing credentials for this resource, if any.
9426        '''
9427        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9428        '''
9429         Tags is a map of key, value pairs.
9430        '''
9431        self.username = username if username is not None else ''
9432        '''
9433
9434        '''
9435
9436    def __repr__(self):
9437        return '<sdm.Postgres ' + \
9438            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9439            'database: ' + repr(self.database) + ' ' +\
9440            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9441            'healthy: ' + repr(self.healthy) + ' ' +\
9442            'hostname: ' + repr(self.hostname) + ' ' +\
9443            'id: ' + repr(self.id) + ' ' +\
9444            'name: ' + repr(self.name) + ' ' +\
9445            'override_database: ' + repr(self.override_database) + ' ' +\
9446            'password: ' + repr(self.password) + ' ' +\
9447            'port: ' + repr(self.port) + ' ' +\
9448            'port_override: ' + repr(self.port_override) + ' ' +\
9449            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9450            'tags: ' + repr(self.tags) + ' ' +\
9451            'username: ' + repr(self.username) + ' ' +\
9452            '>'
9453
9454    def to_dict(self):
9455        return {
9456            'bind_interface': self.bind_interface,
9457            'database': self.database,
9458            'egress_filter': self.egress_filter,
9459            'healthy': self.healthy,
9460            'hostname': self.hostname,
9461            'id': self.id,
9462            'name': self.name,
9463            'override_database': self.override_database,
9464            'password': self.password,
9465            'port': self.port,
9466            'port_override': self.port_override,
9467            'secret_store_id': self.secret_store_id,
9468            'tags': self.tags,
9469            'username': self.username,
9470        }
9471
9472    @classmethod
9473    def from_dict(cls, d):
9474        return cls(
9475            bind_interface=d.get('bind_interface'),
9476            database=d.get('database'),
9477            egress_filter=d.get('egress_filter'),
9478            healthy=d.get('healthy'),
9479            hostname=d.get('hostname'),
9480            id=d.get('id'),
9481            name=d.get('name'),
9482            override_database=d.get('override_database'),
9483            password=d.get('password'),
9484            port=d.get('port'),
9485            port_override=d.get('port_override'),
9486            secret_store_id=d.get('secret_store_id'),
9487            tags=d.get('tags'),
9488            username=d.get('username'),
9489        )
Postgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
9362    def __init__(
9363        self,
9364        bind_interface=None,
9365        database=None,
9366        egress_filter=None,
9367        healthy=None,
9368        hostname=None,
9369        id=None,
9370        name=None,
9371        override_database=None,
9372        password=None,
9373        port=None,
9374        port_override=None,
9375        secret_store_id=None,
9376        tags=None,
9377        username=None,
9378    ):
9379        self.bind_interface = bind_interface if bind_interface is not None else ''
9380        '''
9381         Bind interface
9382        '''
9383        self.database = database if database is not None else ''
9384        '''
9385
9386        '''
9387        self.egress_filter = egress_filter if egress_filter is not None else ''
9388        '''
9389         A filter applied to the routing logic to pin datasource to nodes.
9390        '''
9391        self.healthy = healthy if healthy is not None else False
9392        '''
9393         True if the datasource is reachable and the credentials are valid.
9394        '''
9395        self.hostname = hostname if hostname is not None else ''
9396        '''
9397
9398        '''
9399        self.id = id if id is not None else ''
9400        '''
9401         Unique identifier of the Resource.
9402        '''
9403        self.name = name if name is not None else ''
9404        '''
9405         Unique human-readable name of the Resource.
9406        '''
9407        self.override_database = override_database if override_database is not None else False
9408        '''
9409
9410        '''
9411        self.password = password if password is not None else ''
9412        '''
9413
9414        '''
9415        self.port = port if port is not None else 0
9416        '''
9417
9418        '''
9419        self.port_override = port_override if port_override is not None else 0
9420        '''
9421
9422        '''
9423        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9424        '''
9425         ID of the secret store containing credentials for this resource, if any.
9426        '''
9427        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9428        '''
9429         Tags is a map of key, value pairs.
9430        '''
9431        self.username = username if username is not None else ''
9432        '''
9433
9434        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
9454    def to_dict(self):
9455        return {
9456            'bind_interface': self.bind_interface,
9457            'database': self.database,
9458            'egress_filter': self.egress_filter,
9459            'healthy': self.healthy,
9460            'hostname': self.hostname,
9461            'id': self.id,
9462            'name': self.name,
9463            'override_database': self.override_database,
9464            'password': self.password,
9465            'port': self.port,
9466            'port_override': self.port_override,
9467            'secret_store_id': self.secret_store_id,
9468            'tags': self.tags,
9469            'username': self.username,
9470        }
@classmethod
def from_dict(cls, d)
9472    @classmethod
9473    def from_dict(cls, d):
9474        return cls(
9475            bind_interface=d.get('bind_interface'),
9476            database=d.get('database'),
9477            egress_filter=d.get('egress_filter'),
9478            healthy=d.get('healthy'),
9479            hostname=d.get('hostname'),
9480            id=d.get('id'),
9481            name=d.get('name'),
9482            override_database=d.get('override_database'),
9483            password=d.get('password'),
9484            port=d.get('port'),
9485            port_override=d.get('port_override'),
9486            secret_store_id=d.get('secret_store_id'),
9487            tags=d.get('tags'),
9488            username=d.get('username'),
9489        )
class Presto:
9492class Presto:
9493    '''
9494
9495    '''
9496    __slots__ = [
9497        'bind_interface',
9498        'database',
9499        'egress_filter',
9500        'healthy',
9501        'hostname',
9502        'id',
9503        'name',
9504        'password',
9505        'port',
9506        'port_override',
9507        'secret_store_id',
9508        'tags',
9509        'tls_required',
9510        'username',
9511    ]
9512
9513    def __init__(
9514        self,
9515        bind_interface=None,
9516        database=None,
9517        egress_filter=None,
9518        healthy=None,
9519        hostname=None,
9520        id=None,
9521        name=None,
9522        password=None,
9523        port=None,
9524        port_override=None,
9525        secret_store_id=None,
9526        tags=None,
9527        tls_required=None,
9528        username=None,
9529    ):
9530        self.bind_interface = bind_interface if bind_interface is not None else ''
9531        '''
9532         Bind interface
9533        '''
9534        self.database = database if database is not None else ''
9535        '''
9536
9537        '''
9538        self.egress_filter = egress_filter if egress_filter is not None else ''
9539        '''
9540         A filter applied to the routing logic to pin datasource to nodes.
9541        '''
9542        self.healthy = healthy if healthy is not None else False
9543        '''
9544         True if the datasource is reachable and the credentials are valid.
9545        '''
9546        self.hostname = hostname if hostname is not None else ''
9547        '''
9548
9549        '''
9550        self.id = id if id is not None else ''
9551        '''
9552         Unique identifier of the Resource.
9553        '''
9554        self.name = name if name is not None else ''
9555        '''
9556         Unique human-readable name of the Resource.
9557        '''
9558        self.password = password if password is not None else ''
9559        '''
9560
9561        '''
9562        self.port = port if port is not None else 0
9563        '''
9564
9565        '''
9566        self.port_override = port_override if port_override is not None else 0
9567        '''
9568
9569        '''
9570        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9571        '''
9572         ID of the secret store containing credentials for this resource, if any.
9573        '''
9574        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9575        '''
9576         Tags is a map of key, value pairs.
9577        '''
9578        self.tls_required = tls_required if tls_required is not None else False
9579        '''
9580
9581        '''
9582        self.username = username if username is not None else ''
9583        '''
9584
9585        '''
9586
9587    def __repr__(self):
9588        return '<sdm.Presto ' + \
9589            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9590            'database: ' + repr(self.database) + ' ' +\
9591            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9592            'healthy: ' + repr(self.healthy) + ' ' +\
9593            'hostname: ' + repr(self.hostname) + ' ' +\
9594            'id: ' + repr(self.id) + ' ' +\
9595            'name: ' + repr(self.name) + ' ' +\
9596            'password: ' + repr(self.password) + ' ' +\
9597            'port: ' + repr(self.port) + ' ' +\
9598            'port_override: ' + repr(self.port_override) + ' ' +\
9599            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9600            'tags: ' + repr(self.tags) + ' ' +\
9601            'tls_required: ' + repr(self.tls_required) + ' ' +\
9602            'username: ' + repr(self.username) + ' ' +\
9603            '>'
9604
9605    def to_dict(self):
9606        return {
9607            'bind_interface': self.bind_interface,
9608            'database': self.database,
9609            'egress_filter': self.egress_filter,
9610            'healthy': self.healthy,
9611            'hostname': self.hostname,
9612            'id': self.id,
9613            'name': self.name,
9614            'password': self.password,
9615            'port': self.port,
9616            'port_override': self.port_override,
9617            'secret_store_id': self.secret_store_id,
9618            'tags': self.tags,
9619            'tls_required': self.tls_required,
9620            'username': self.username,
9621        }
9622
9623    @classmethod
9624    def from_dict(cls, d):
9625        return cls(
9626            bind_interface=d.get('bind_interface'),
9627            database=d.get('database'),
9628            egress_filter=d.get('egress_filter'),
9629            healthy=d.get('healthy'),
9630            hostname=d.get('hostname'),
9631            id=d.get('id'),
9632            name=d.get('name'),
9633            password=d.get('password'),
9634            port=d.get('port'),
9635            port_override=d.get('port_override'),
9636            secret_store_id=d.get('secret_store_id'),
9637            tags=d.get('tags'),
9638            tls_required=d.get('tls_required'),
9639            username=d.get('username'),
9640        )
Presto( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
9513    def __init__(
9514        self,
9515        bind_interface=None,
9516        database=None,
9517        egress_filter=None,
9518        healthy=None,
9519        hostname=None,
9520        id=None,
9521        name=None,
9522        password=None,
9523        port=None,
9524        port_override=None,
9525        secret_store_id=None,
9526        tags=None,
9527        tls_required=None,
9528        username=None,
9529    ):
9530        self.bind_interface = bind_interface if bind_interface is not None else ''
9531        '''
9532         Bind interface
9533        '''
9534        self.database = database if database is not None else ''
9535        '''
9536
9537        '''
9538        self.egress_filter = egress_filter if egress_filter is not None else ''
9539        '''
9540         A filter applied to the routing logic to pin datasource to nodes.
9541        '''
9542        self.healthy = healthy if healthy is not None else False
9543        '''
9544         True if the datasource is reachable and the credentials are valid.
9545        '''
9546        self.hostname = hostname if hostname is not None else ''
9547        '''
9548
9549        '''
9550        self.id = id if id is not None else ''
9551        '''
9552         Unique identifier of the Resource.
9553        '''
9554        self.name = name if name is not None else ''
9555        '''
9556         Unique human-readable name of the Resource.
9557        '''
9558        self.password = password if password is not None else ''
9559        '''
9560
9561        '''
9562        self.port = port if port is not None else 0
9563        '''
9564
9565        '''
9566        self.port_override = port_override if port_override is not None else 0
9567        '''
9568
9569        '''
9570        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9571        '''
9572         ID of the secret store containing credentials for this resource, if any.
9573        '''
9574        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9575        '''
9576         Tags is a map of key, value pairs.
9577        '''
9578        self.tls_required = tls_required if tls_required is not None else False
9579        '''
9580
9581        '''
9582        self.username = username if username is not None else ''
9583        '''
9584
9585        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9605    def to_dict(self):
9606        return {
9607            'bind_interface': self.bind_interface,
9608            'database': self.database,
9609            'egress_filter': self.egress_filter,
9610            'healthy': self.healthy,
9611            'hostname': self.hostname,
9612            'id': self.id,
9613            'name': self.name,
9614            'password': self.password,
9615            'port': self.port,
9616            'port_override': self.port_override,
9617            'secret_store_id': self.secret_store_id,
9618            'tags': self.tags,
9619            'tls_required': self.tls_required,
9620            'username': self.username,
9621        }
@classmethod
def from_dict(cls, d)
9623    @classmethod
9624    def from_dict(cls, d):
9625        return cls(
9626            bind_interface=d.get('bind_interface'),
9627            database=d.get('database'),
9628            egress_filter=d.get('egress_filter'),
9629            healthy=d.get('healthy'),
9630            hostname=d.get('hostname'),
9631            id=d.get('id'),
9632            name=d.get('name'),
9633            password=d.get('password'),
9634            port=d.get('port'),
9635            port_override=d.get('port_override'),
9636            secret_store_id=d.get('secret_store_id'),
9637            tags=d.get('tags'),
9638            tls_required=d.get('tls_required'),
9639            username=d.get('username'),
9640        )
class RDP:
9643class RDP:
9644    '''
9645
9646    '''
9647    __slots__ = [
9648        'bind_interface',
9649        'downgrade_nla_connections',
9650        'egress_filter',
9651        'healthy',
9652        'hostname',
9653        'id',
9654        'name',
9655        'password',
9656        'port',
9657        'port_override',
9658        'secret_store_id',
9659        'tags',
9660        'username',
9661    ]
9662
9663    def __init__(
9664        self,
9665        bind_interface=None,
9666        downgrade_nla_connections=None,
9667        egress_filter=None,
9668        healthy=None,
9669        hostname=None,
9670        id=None,
9671        name=None,
9672        password=None,
9673        port=None,
9674        port_override=None,
9675        secret_store_id=None,
9676        tags=None,
9677        username=None,
9678    ):
9679        self.bind_interface = bind_interface if bind_interface is not None else ''
9680        '''
9681         Bind interface
9682        '''
9683        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
9684        '''
9685
9686        '''
9687        self.egress_filter = egress_filter if egress_filter is not None else ''
9688        '''
9689         A filter applied to the routing logic to pin datasource to nodes.
9690        '''
9691        self.healthy = healthy if healthy is not None else False
9692        '''
9693         True if the datasource is reachable and the credentials are valid.
9694        '''
9695        self.hostname = hostname if hostname is not None else ''
9696        '''
9697
9698        '''
9699        self.id = id if id is not None else ''
9700        '''
9701         Unique identifier of the Resource.
9702        '''
9703        self.name = name if name is not None else ''
9704        '''
9705         Unique human-readable name of the Resource.
9706        '''
9707        self.password = password if password is not None else ''
9708        '''
9709
9710        '''
9711        self.port = port if port is not None else 0
9712        '''
9713
9714        '''
9715        self.port_override = port_override if port_override is not None else 0
9716        '''
9717
9718        '''
9719        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9720        '''
9721         ID of the secret store containing credentials for this resource, if any.
9722        '''
9723        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9724        '''
9725         Tags is a map of key, value pairs.
9726        '''
9727        self.username = username if username is not None else ''
9728        '''
9729
9730        '''
9731
9732    def __repr__(self):
9733        return '<sdm.RDP ' + \
9734            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9735            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
9736            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9737            'healthy: ' + repr(self.healthy) + ' ' +\
9738            'hostname: ' + repr(self.hostname) + ' ' +\
9739            'id: ' + repr(self.id) + ' ' +\
9740            'name: ' + repr(self.name) + ' ' +\
9741            'password: ' + repr(self.password) + ' ' +\
9742            'port: ' + repr(self.port) + ' ' +\
9743            'port_override: ' + repr(self.port_override) + ' ' +\
9744            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9745            'tags: ' + repr(self.tags) + ' ' +\
9746            'username: ' + repr(self.username) + ' ' +\
9747            '>'
9748
9749    def to_dict(self):
9750        return {
9751            'bind_interface': self.bind_interface,
9752            'downgrade_nla_connections': self.downgrade_nla_connections,
9753            'egress_filter': self.egress_filter,
9754            'healthy': self.healthy,
9755            'hostname': self.hostname,
9756            'id': self.id,
9757            'name': self.name,
9758            'password': self.password,
9759            'port': self.port,
9760            'port_override': self.port_override,
9761            'secret_store_id': self.secret_store_id,
9762            'tags': self.tags,
9763            'username': self.username,
9764        }
9765
9766    @classmethod
9767    def from_dict(cls, d):
9768        return cls(
9769            bind_interface=d.get('bind_interface'),
9770            downgrade_nla_connections=d.get('downgrade_nla_connections'),
9771            egress_filter=d.get('egress_filter'),
9772            healthy=d.get('healthy'),
9773            hostname=d.get('hostname'),
9774            id=d.get('id'),
9775            name=d.get('name'),
9776            password=d.get('password'),
9777            port=d.get('port'),
9778            port_override=d.get('port_override'),
9779            secret_store_id=d.get('secret_store_id'),
9780            tags=d.get('tags'),
9781            username=d.get('username'),
9782        )
RDP( bind_interface=None, downgrade_nla_connections=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
9663    def __init__(
9664        self,
9665        bind_interface=None,
9666        downgrade_nla_connections=None,
9667        egress_filter=None,
9668        healthy=None,
9669        hostname=None,
9670        id=None,
9671        name=None,
9672        password=None,
9673        port=None,
9674        port_override=None,
9675        secret_store_id=None,
9676        tags=None,
9677        username=None,
9678    ):
9679        self.bind_interface = bind_interface if bind_interface is not None else ''
9680        '''
9681         Bind interface
9682        '''
9683        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
9684        '''
9685
9686        '''
9687        self.egress_filter = egress_filter if egress_filter is not None else ''
9688        '''
9689         A filter applied to the routing logic to pin datasource to nodes.
9690        '''
9691        self.healthy = healthy if healthy is not None else False
9692        '''
9693         True if the datasource is reachable and the credentials are valid.
9694        '''
9695        self.hostname = hostname if hostname is not None else ''
9696        '''
9697
9698        '''
9699        self.id = id if id is not None else ''
9700        '''
9701         Unique identifier of the Resource.
9702        '''
9703        self.name = name if name is not None else ''
9704        '''
9705         Unique human-readable name of the Resource.
9706        '''
9707        self.password = password if password is not None else ''
9708        '''
9709
9710        '''
9711        self.port = port if port is not None else 0
9712        '''
9713
9714        '''
9715        self.port_override = port_override if port_override is not None else 0
9716        '''
9717
9718        '''
9719        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9720        '''
9721         ID of the secret store containing credentials for this resource, if any.
9722        '''
9723        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9724        '''
9725         Tags is a map of key, value pairs.
9726        '''
9727        self.username = username if username is not None else ''
9728        '''
9729
9730        '''
bind_interface

Bind interface

downgrade_nla_connections
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
9749    def to_dict(self):
9750        return {
9751            'bind_interface': self.bind_interface,
9752            'downgrade_nla_connections': self.downgrade_nla_connections,
9753            'egress_filter': self.egress_filter,
9754            'healthy': self.healthy,
9755            'hostname': self.hostname,
9756            'id': self.id,
9757            'name': self.name,
9758            'password': self.password,
9759            'port': self.port,
9760            'port_override': self.port_override,
9761            'secret_store_id': self.secret_store_id,
9762            'tags': self.tags,
9763            'username': self.username,
9764        }
@classmethod
def from_dict(cls, d)
9766    @classmethod
9767    def from_dict(cls, d):
9768        return cls(
9769            bind_interface=d.get('bind_interface'),
9770            downgrade_nla_connections=d.get('downgrade_nla_connections'),
9771            egress_filter=d.get('egress_filter'),
9772            healthy=d.get('healthy'),
9773            hostname=d.get('hostname'),
9774            id=d.get('id'),
9775            name=d.get('name'),
9776            password=d.get('password'),
9777            port=d.get('port'),
9778            port_override=d.get('port_override'),
9779            secret_store_id=d.get('secret_store_id'),
9780            tags=d.get('tags'),
9781            username=d.get('username'),
9782        )
class RabbitMQAMQP091:
9785class RabbitMQAMQP091:
9786    '''
9787
9788    '''
9789    __slots__ = [
9790        'bind_interface',
9791        'egress_filter',
9792        'healthy',
9793        'hostname',
9794        'id',
9795        'name',
9796        'password',
9797        'port',
9798        'port_override',
9799        'secret_store_id',
9800        'tags',
9801        'tls_required',
9802        'username',
9803    ]
9804
9805    def __init__(
9806        self,
9807        bind_interface=None,
9808        egress_filter=None,
9809        healthy=None,
9810        hostname=None,
9811        id=None,
9812        name=None,
9813        password=None,
9814        port=None,
9815        port_override=None,
9816        secret_store_id=None,
9817        tags=None,
9818        tls_required=None,
9819        username=None,
9820    ):
9821        self.bind_interface = bind_interface if bind_interface is not None else ''
9822        '''
9823         Bind interface
9824        '''
9825        self.egress_filter = egress_filter if egress_filter is not None else ''
9826        '''
9827         A filter applied to the routing logic to pin datasource to nodes.
9828        '''
9829        self.healthy = healthy if healthy is not None else False
9830        '''
9831         True if the datasource is reachable and the credentials are valid.
9832        '''
9833        self.hostname = hostname if hostname is not None else ''
9834        '''
9835
9836        '''
9837        self.id = id if id is not None else ''
9838        '''
9839         Unique identifier of the Resource.
9840        '''
9841        self.name = name if name is not None else ''
9842        '''
9843         Unique human-readable name of the Resource.
9844        '''
9845        self.password = password if password is not None else ''
9846        '''
9847
9848        '''
9849        self.port = port if port is not None else 0
9850        '''
9851
9852        '''
9853        self.port_override = port_override if port_override is not None else 0
9854        '''
9855
9856        '''
9857        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9858        '''
9859         ID of the secret store containing credentials for this resource, if any.
9860        '''
9861        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9862        '''
9863         Tags is a map of key, value pairs.
9864        '''
9865        self.tls_required = tls_required if tls_required is not None else False
9866        '''
9867
9868        '''
9869        self.username = username if username is not None else ''
9870        '''
9871
9872        '''
9873
9874    def __repr__(self):
9875        return '<sdm.RabbitMQAMQP091 ' + \
9876            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9877            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9878            'healthy: ' + repr(self.healthy) + ' ' +\
9879            'hostname: ' + repr(self.hostname) + ' ' +\
9880            'id: ' + repr(self.id) + ' ' +\
9881            'name: ' + repr(self.name) + ' ' +\
9882            'password: ' + repr(self.password) + ' ' +\
9883            'port: ' + repr(self.port) + ' ' +\
9884            'port_override: ' + repr(self.port_override) + ' ' +\
9885            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9886            'tags: ' + repr(self.tags) + ' ' +\
9887            'tls_required: ' + repr(self.tls_required) + ' ' +\
9888            'username: ' + repr(self.username) + ' ' +\
9889            '>'
9890
9891    def to_dict(self):
9892        return {
9893            'bind_interface': self.bind_interface,
9894            'egress_filter': self.egress_filter,
9895            'healthy': self.healthy,
9896            'hostname': self.hostname,
9897            'id': self.id,
9898            'name': self.name,
9899            'password': self.password,
9900            'port': self.port,
9901            'port_override': self.port_override,
9902            'secret_store_id': self.secret_store_id,
9903            'tags': self.tags,
9904            'tls_required': self.tls_required,
9905            'username': self.username,
9906        }
9907
9908    @classmethod
9909    def from_dict(cls, d):
9910        return cls(
9911            bind_interface=d.get('bind_interface'),
9912            egress_filter=d.get('egress_filter'),
9913            healthy=d.get('healthy'),
9914            hostname=d.get('hostname'),
9915            id=d.get('id'),
9916            name=d.get('name'),
9917            password=d.get('password'),
9918            port=d.get('port'),
9919            port_override=d.get('port_override'),
9920            secret_store_id=d.get('secret_store_id'),
9921            tags=d.get('tags'),
9922            tls_required=d.get('tls_required'),
9923            username=d.get('username'),
9924        )
RabbitMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
9805    def __init__(
9806        self,
9807        bind_interface=None,
9808        egress_filter=None,
9809        healthy=None,
9810        hostname=None,
9811        id=None,
9812        name=None,
9813        password=None,
9814        port=None,
9815        port_override=None,
9816        secret_store_id=None,
9817        tags=None,
9818        tls_required=None,
9819        username=None,
9820    ):
9821        self.bind_interface = bind_interface if bind_interface is not None else ''
9822        '''
9823         Bind interface
9824        '''
9825        self.egress_filter = egress_filter if egress_filter is not None else ''
9826        '''
9827         A filter applied to the routing logic to pin datasource to nodes.
9828        '''
9829        self.healthy = healthy if healthy is not None else False
9830        '''
9831         True if the datasource is reachable and the credentials are valid.
9832        '''
9833        self.hostname = hostname if hostname is not None else ''
9834        '''
9835
9836        '''
9837        self.id = id if id is not None else ''
9838        '''
9839         Unique identifier of the Resource.
9840        '''
9841        self.name = name if name is not None else ''
9842        '''
9843         Unique human-readable name of the Resource.
9844        '''
9845        self.password = password if password is not None else ''
9846        '''
9847
9848        '''
9849        self.port = port if port is not None else 0
9850        '''
9851
9852        '''
9853        self.port_override = port_override if port_override is not None else 0
9854        '''
9855
9856        '''
9857        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9858        '''
9859         ID of the secret store containing credentials for this resource, if any.
9860        '''
9861        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9862        '''
9863         Tags is a map of key, value pairs.
9864        '''
9865        self.tls_required = tls_required if tls_required is not None else False
9866        '''
9867
9868        '''
9869        self.username = username if username is not None else ''
9870        '''
9871
9872        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9891    def to_dict(self):
9892        return {
9893            'bind_interface': self.bind_interface,
9894            'egress_filter': self.egress_filter,
9895            'healthy': self.healthy,
9896            'hostname': self.hostname,
9897            'id': self.id,
9898            'name': self.name,
9899            'password': self.password,
9900            'port': self.port,
9901            'port_override': self.port_override,
9902            'secret_store_id': self.secret_store_id,
9903            'tags': self.tags,
9904            'tls_required': self.tls_required,
9905            'username': self.username,
9906        }
@classmethod
def from_dict(cls, d)
9908    @classmethod
9909    def from_dict(cls, d):
9910        return cls(
9911            bind_interface=d.get('bind_interface'),
9912            egress_filter=d.get('egress_filter'),
9913            healthy=d.get('healthy'),
9914            hostname=d.get('hostname'),
9915            id=d.get('id'),
9916            name=d.get('name'),
9917            password=d.get('password'),
9918            port=d.get('port'),
9919            port_override=d.get('port_override'),
9920            secret_store_id=d.get('secret_store_id'),
9921            tags=d.get('tags'),
9922            tls_required=d.get('tls_required'),
9923            username=d.get('username'),
9924        )
class RateLimitMetadata:
9927class RateLimitMetadata:
9928    '''
9929     RateLimitMetadata contains information about remaining requests avaialable
9930     to the user over some timeframe.
9931    '''
9932    __slots__ = [
9933        'bucket',
9934        'limit',
9935        'remaining',
9936        'reset_at',
9937    ]
9938
9939    def __init__(
9940        self,
9941        bucket=None,
9942        limit=None,
9943        remaining=None,
9944        reset_at=None,
9945    ):
9946        self.bucket = bucket if bucket is not None else ''
9947        '''
9948         The bucket this user/token is associated with, which may be shared between
9949         multiple users/tokens.
9950        '''
9951        self.limit = limit if limit is not None else 0
9952        '''
9953         How many total requests the user/token is authorized to make before being
9954         rate limited.
9955        '''
9956        self.remaining = remaining if remaining is not None else 0
9957        '''
9958         How many remaining requests out of the limit are still avaialable.
9959        '''
9960        self.reset_at = reset_at if reset_at is not None else None
9961        '''
9962         The time when remaining will be reset to limit.
9963        '''
9964
9965    def __repr__(self):
9966        return '<sdm.RateLimitMetadata ' + \
9967            'bucket: ' + repr(self.bucket) + ' ' +\
9968            'limit: ' + repr(self.limit) + ' ' +\
9969            'remaining: ' + repr(self.remaining) + ' ' +\
9970            'reset_at: ' + repr(self.reset_at) + ' ' +\
9971            '>'
9972
9973    def to_dict(self):
9974        return {
9975            'bucket': self.bucket,
9976            'limit': self.limit,
9977            'remaining': self.remaining,
9978            'reset_at': self.reset_at,
9979        }
9980
9981    @classmethod
9982    def from_dict(cls, d):
9983        return cls(
9984            bucket=d.get('bucket'),
9985            limit=d.get('limit'),
9986            remaining=d.get('remaining'),
9987            reset_at=d.get('reset_at'),
9988        )

RateLimitMetadata contains information about remaining requests avaialable to the user over some timeframe.

RateLimitMetadata(bucket=None, limit=None, remaining=None, reset_at=None)
9939    def __init__(
9940        self,
9941        bucket=None,
9942        limit=None,
9943        remaining=None,
9944        reset_at=None,
9945    ):
9946        self.bucket = bucket if bucket is not None else ''
9947        '''
9948         The bucket this user/token is associated with, which may be shared between
9949         multiple users/tokens.
9950        '''
9951        self.limit = limit if limit is not None else 0
9952        '''
9953         How many total requests the user/token is authorized to make before being
9954         rate limited.
9955        '''
9956        self.remaining = remaining if remaining is not None else 0
9957        '''
9958         How many remaining requests out of the limit are still avaialable.
9959        '''
9960        self.reset_at = reset_at if reset_at is not None else None
9961        '''
9962         The time when remaining will be reset to limit.
9963        '''
bucket

The bucket this user/token is associated with, which may be shared between multiple users/tokens.

limit

How many total requests the user/token is authorized to make before being rate limited.

remaining

How many remaining requests out of the limit are still avaialable.

reset_at

The time when remaining will be reset to limit.

def to_dict(self)
9973    def to_dict(self):
9974        return {
9975            'bucket': self.bucket,
9976            'limit': self.limit,
9977            'remaining': self.remaining,
9978            'reset_at': self.reset_at,
9979        }
@classmethod
def from_dict(cls, d)
9981    @classmethod
9982    def from_dict(cls, d):
9983        return cls(
9984            bucket=d.get('bucket'),
9985            limit=d.get('limit'),
9986            remaining=d.get('remaining'),
9987            reset_at=d.get('reset_at'),
9988        )
class RawTCP:
 9991class RawTCP:
 9992    '''
 9993
 9994    '''
 9995    __slots__ = [
 9996        'bind_interface',
 9997        'egress_filter',
 9998        'healthy',
 9999        'hostname',
10000        'id',
10001        'name',
10002        'port',
10003        'port_override',
10004        'secret_store_id',
10005        'tags',
10006    ]
10007
10008    def __init__(
10009        self,
10010        bind_interface=None,
10011        egress_filter=None,
10012        healthy=None,
10013        hostname=None,
10014        id=None,
10015        name=None,
10016        port=None,
10017        port_override=None,
10018        secret_store_id=None,
10019        tags=None,
10020    ):
10021        self.bind_interface = bind_interface if bind_interface is not None else ''
10022        '''
10023         Bind interface
10024        '''
10025        self.egress_filter = egress_filter if egress_filter is not None else ''
10026        '''
10027         A filter applied to the routing logic to pin datasource to nodes.
10028        '''
10029        self.healthy = healthy if healthy is not None else False
10030        '''
10031         True if the datasource is reachable and the credentials are valid.
10032        '''
10033        self.hostname = hostname if hostname is not None else ''
10034        '''
10035
10036        '''
10037        self.id = id if id is not None else ''
10038        '''
10039         Unique identifier of the Resource.
10040        '''
10041        self.name = name if name is not None else ''
10042        '''
10043         Unique human-readable name of the Resource.
10044        '''
10045        self.port = port if port is not None else 0
10046        '''
10047
10048        '''
10049        self.port_override = port_override if port_override is not None else 0
10050        '''
10051
10052        '''
10053        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10054        '''
10055         ID of the secret store containing credentials for this resource, if any.
10056        '''
10057        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10058        '''
10059         Tags is a map of key, value pairs.
10060        '''
10061
10062    def __repr__(self):
10063        return '<sdm.RawTCP ' + \
10064            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10065            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10066            'healthy: ' + repr(self.healthy) + ' ' +\
10067            'hostname: ' + repr(self.hostname) + ' ' +\
10068            'id: ' + repr(self.id) + ' ' +\
10069            'name: ' + repr(self.name) + ' ' +\
10070            'port: ' + repr(self.port) + ' ' +\
10071            'port_override: ' + repr(self.port_override) + ' ' +\
10072            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10073            'tags: ' + repr(self.tags) + ' ' +\
10074            '>'
10075
10076    def to_dict(self):
10077        return {
10078            'bind_interface': self.bind_interface,
10079            'egress_filter': self.egress_filter,
10080            'healthy': self.healthy,
10081            'hostname': self.hostname,
10082            'id': self.id,
10083            'name': self.name,
10084            'port': self.port,
10085            'port_override': self.port_override,
10086            'secret_store_id': self.secret_store_id,
10087            'tags': self.tags,
10088        }
10089
10090    @classmethod
10091    def from_dict(cls, d):
10092        return cls(
10093            bind_interface=d.get('bind_interface'),
10094            egress_filter=d.get('egress_filter'),
10095            healthy=d.get('healthy'),
10096            hostname=d.get('hostname'),
10097            id=d.get('id'),
10098            name=d.get('name'),
10099            port=d.get('port'),
10100            port_override=d.get('port_override'),
10101            secret_store_id=d.get('secret_store_id'),
10102            tags=d.get('tags'),
10103        )
RawTCP( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
10008    def __init__(
10009        self,
10010        bind_interface=None,
10011        egress_filter=None,
10012        healthy=None,
10013        hostname=None,
10014        id=None,
10015        name=None,
10016        port=None,
10017        port_override=None,
10018        secret_store_id=None,
10019        tags=None,
10020    ):
10021        self.bind_interface = bind_interface if bind_interface is not None else ''
10022        '''
10023         Bind interface
10024        '''
10025        self.egress_filter = egress_filter if egress_filter is not None else ''
10026        '''
10027         A filter applied to the routing logic to pin datasource to nodes.
10028        '''
10029        self.healthy = healthy if healthy is not None else False
10030        '''
10031         True if the datasource is reachable and the credentials are valid.
10032        '''
10033        self.hostname = hostname if hostname is not None else ''
10034        '''
10035
10036        '''
10037        self.id = id if id is not None else ''
10038        '''
10039         Unique identifier of the Resource.
10040        '''
10041        self.name = name if name is not None else ''
10042        '''
10043         Unique human-readable name of the Resource.
10044        '''
10045        self.port = port if port is not None else 0
10046        '''
10047
10048        '''
10049        self.port_override = port_override if port_override is not None else 0
10050        '''
10051
10052        '''
10053        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10054        '''
10055         ID of the secret store containing credentials for this resource, if any.
10056        '''
10057        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10058        '''
10059         Tags is a map of key, value pairs.
10060        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
10076    def to_dict(self):
10077        return {
10078            'bind_interface': self.bind_interface,
10079            'egress_filter': self.egress_filter,
10080            'healthy': self.healthy,
10081            'hostname': self.hostname,
10082            'id': self.id,
10083            'name': self.name,
10084            'port': self.port,
10085            'port_override': self.port_override,
10086            'secret_store_id': self.secret_store_id,
10087            'tags': self.tags,
10088        }
@classmethod
def from_dict(cls, d)
10090    @classmethod
10091    def from_dict(cls, d):
10092        return cls(
10093            bind_interface=d.get('bind_interface'),
10094            egress_filter=d.get('egress_filter'),
10095            healthy=d.get('healthy'),
10096            hostname=d.get('hostname'),
10097            id=d.get('id'),
10098            name=d.get('name'),
10099            port=d.get('port'),
10100            port_override=d.get('port_override'),
10101            secret_store_id=d.get('secret_store_id'),
10102            tags=d.get('tags'),
10103        )
class Redis:
10106class Redis:
10107    '''
10108
10109    '''
10110    __slots__ = [
10111        'bind_interface',
10112        'egress_filter',
10113        'healthy',
10114        'hostname',
10115        'id',
10116        'name',
10117        'password',
10118        'port',
10119        'port_override',
10120        'secret_store_id',
10121        'tags',
10122    ]
10123
10124    def __init__(
10125        self,
10126        bind_interface=None,
10127        egress_filter=None,
10128        healthy=None,
10129        hostname=None,
10130        id=None,
10131        name=None,
10132        password=None,
10133        port=None,
10134        port_override=None,
10135        secret_store_id=None,
10136        tags=None,
10137    ):
10138        self.bind_interface = bind_interface if bind_interface is not None else ''
10139        '''
10140         Bind interface
10141        '''
10142        self.egress_filter = egress_filter if egress_filter is not None else ''
10143        '''
10144         A filter applied to the routing logic to pin datasource to nodes.
10145        '''
10146        self.healthy = healthy if healthy is not None else False
10147        '''
10148         True if the datasource is reachable and the credentials are valid.
10149        '''
10150        self.hostname = hostname if hostname is not None else ''
10151        '''
10152
10153        '''
10154        self.id = id if id is not None else ''
10155        '''
10156         Unique identifier of the Resource.
10157        '''
10158        self.name = name if name is not None else ''
10159        '''
10160         Unique human-readable name of the Resource.
10161        '''
10162        self.password = password if password is not None else ''
10163        '''
10164
10165        '''
10166        self.port = port if port is not None else 0
10167        '''
10168
10169        '''
10170        self.port_override = port_override if port_override is not None else 0
10171        '''
10172
10173        '''
10174        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10175        '''
10176         ID of the secret store containing credentials for this resource, if any.
10177        '''
10178        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10179        '''
10180         Tags is a map of key, value pairs.
10181        '''
10182
10183    def __repr__(self):
10184        return '<sdm.Redis ' + \
10185            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10186            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10187            'healthy: ' + repr(self.healthy) + ' ' +\
10188            'hostname: ' + repr(self.hostname) + ' ' +\
10189            'id: ' + repr(self.id) + ' ' +\
10190            'name: ' + repr(self.name) + ' ' +\
10191            'password: ' + repr(self.password) + ' ' +\
10192            'port: ' + repr(self.port) + ' ' +\
10193            'port_override: ' + repr(self.port_override) + ' ' +\
10194            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10195            'tags: ' + repr(self.tags) + ' ' +\
10196            '>'
10197
10198    def to_dict(self):
10199        return {
10200            'bind_interface': self.bind_interface,
10201            'egress_filter': self.egress_filter,
10202            'healthy': self.healthy,
10203            'hostname': self.hostname,
10204            'id': self.id,
10205            'name': self.name,
10206            'password': self.password,
10207            'port': self.port,
10208            'port_override': self.port_override,
10209            'secret_store_id': self.secret_store_id,
10210            'tags': self.tags,
10211        }
10212
10213    @classmethod
10214    def from_dict(cls, d):
10215        return cls(
10216            bind_interface=d.get('bind_interface'),
10217            egress_filter=d.get('egress_filter'),
10218            healthy=d.get('healthy'),
10219            hostname=d.get('hostname'),
10220            id=d.get('id'),
10221            name=d.get('name'),
10222            password=d.get('password'),
10223            port=d.get('port'),
10224            port_override=d.get('port_override'),
10225            secret_store_id=d.get('secret_store_id'),
10226            tags=d.get('tags'),
10227        )
Redis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None)
10124    def __init__(
10125        self,
10126        bind_interface=None,
10127        egress_filter=None,
10128        healthy=None,
10129        hostname=None,
10130        id=None,
10131        name=None,
10132        password=None,
10133        port=None,
10134        port_override=None,
10135        secret_store_id=None,
10136        tags=None,
10137    ):
10138        self.bind_interface = bind_interface if bind_interface is not None else ''
10139        '''
10140         Bind interface
10141        '''
10142        self.egress_filter = egress_filter if egress_filter is not None else ''
10143        '''
10144         A filter applied to the routing logic to pin datasource to nodes.
10145        '''
10146        self.healthy = healthy if healthy is not None else False
10147        '''
10148         True if the datasource is reachable and the credentials are valid.
10149        '''
10150        self.hostname = hostname if hostname is not None else ''
10151        '''
10152
10153        '''
10154        self.id = id if id is not None else ''
10155        '''
10156         Unique identifier of the Resource.
10157        '''
10158        self.name = name if name is not None else ''
10159        '''
10160         Unique human-readable name of the Resource.
10161        '''
10162        self.password = password if password is not None else ''
10163        '''
10164
10165        '''
10166        self.port = port if port is not None else 0
10167        '''
10168
10169        '''
10170        self.port_override = port_override if port_override is not None else 0
10171        '''
10172
10173        '''
10174        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10175        '''
10176         ID of the secret store containing credentials for this resource, if any.
10177        '''
10178        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10179        '''
10180         Tags is a map of key, value pairs.
10181        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
10198    def to_dict(self):
10199        return {
10200            'bind_interface': self.bind_interface,
10201            'egress_filter': self.egress_filter,
10202            'healthy': self.healthy,
10203            'hostname': self.hostname,
10204            'id': self.id,
10205            'name': self.name,
10206            'password': self.password,
10207            'port': self.port,
10208            'port_override': self.port_override,
10209            'secret_store_id': self.secret_store_id,
10210            'tags': self.tags,
10211        }
@classmethod
def from_dict(cls, d)
10213    @classmethod
10214    def from_dict(cls, d):
10215        return cls(
10216            bind_interface=d.get('bind_interface'),
10217            egress_filter=d.get('egress_filter'),
10218            healthy=d.get('healthy'),
10219            hostname=d.get('hostname'),
10220            id=d.get('id'),
10221            name=d.get('name'),
10222            password=d.get('password'),
10223            port=d.get('port'),
10224            port_override=d.get('port_override'),
10225            secret_store_id=d.get('secret_store_id'),
10226            tags=d.get('tags'),
10227        )
class Redshift:
10230class Redshift:
10231    '''
10232
10233    '''
10234    __slots__ = [
10235        'bind_interface',
10236        'database',
10237        'egress_filter',
10238        'healthy',
10239        'hostname',
10240        'id',
10241        'name',
10242        'override_database',
10243        'password',
10244        'port',
10245        'port_override',
10246        'secret_store_id',
10247        'tags',
10248        'username',
10249    ]
10250
10251    def __init__(
10252        self,
10253        bind_interface=None,
10254        database=None,
10255        egress_filter=None,
10256        healthy=None,
10257        hostname=None,
10258        id=None,
10259        name=None,
10260        override_database=None,
10261        password=None,
10262        port=None,
10263        port_override=None,
10264        secret_store_id=None,
10265        tags=None,
10266        username=None,
10267    ):
10268        self.bind_interface = bind_interface if bind_interface is not None else ''
10269        '''
10270         Bind interface
10271        '''
10272        self.database = database if database is not None else ''
10273        '''
10274
10275        '''
10276        self.egress_filter = egress_filter if egress_filter is not None else ''
10277        '''
10278         A filter applied to the routing logic to pin datasource to nodes.
10279        '''
10280        self.healthy = healthy if healthy is not None else False
10281        '''
10282         True if the datasource is reachable and the credentials are valid.
10283        '''
10284        self.hostname = hostname if hostname is not None else ''
10285        '''
10286
10287        '''
10288        self.id = id if id is not None else ''
10289        '''
10290         Unique identifier of the Resource.
10291        '''
10292        self.name = name if name is not None else ''
10293        '''
10294         Unique human-readable name of the Resource.
10295        '''
10296        self.override_database = override_database if override_database is not None else False
10297        '''
10298
10299        '''
10300        self.password = password if password is not None else ''
10301        '''
10302
10303        '''
10304        self.port = port if port is not None else 0
10305        '''
10306
10307        '''
10308        self.port_override = port_override if port_override is not None else 0
10309        '''
10310
10311        '''
10312        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10313        '''
10314         ID of the secret store containing credentials for this resource, if any.
10315        '''
10316        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10317        '''
10318         Tags is a map of key, value pairs.
10319        '''
10320        self.username = username if username is not None else ''
10321        '''
10322
10323        '''
10324
10325    def __repr__(self):
10326        return '<sdm.Redshift ' + \
10327            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10328            'database: ' + repr(self.database) + ' ' +\
10329            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10330            'healthy: ' + repr(self.healthy) + ' ' +\
10331            'hostname: ' + repr(self.hostname) + ' ' +\
10332            'id: ' + repr(self.id) + ' ' +\
10333            'name: ' + repr(self.name) + ' ' +\
10334            'override_database: ' + repr(self.override_database) + ' ' +\
10335            'password: ' + repr(self.password) + ' ' +\
10336            'port: ' + repr(self.port) + ' ' +\
10337            'port_override: ' + repr(self.port_override) + ' ' +\
10338            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10339            'tags: ' + repr(self.tags) + ' ' +\
10340            'username: ' + repr(self.username) + ' ' +\
10341            '>'
10342
10343    def to_dict(self):
10344        return {
10345            'bind_interface': self.bind_interface,
10346            'database': self.database,
10347            'egress_filter': self.egress_filter,
10348            'healthy': self.healthy,
10349            'hostname': self.hostname,
10350            'id': self.id,
10351            'name': self.name,
10352            'override_database': self.override_database,
10353            'password': self.password,
10354            'port': self.port,
10355            'port_override': self.port_override,
10356            'secret_store_id': self.secret_store_id,
10357            'tags': self.tags,
10358            'username': self.username,
10359        }
10360
10361    @classmethod
10362    def from_dict(cls, d):
10363        return cls(
10364            bind_interface=d.get('bind_interface'),
10365            database=d.get('database'),
10366            egress_filter=d.get('egress_filter'),
10367            healthy=d.get('healthy'),
10368            hostname=d.get('hostname'),
10369            id=d.get('id'),
10370            name=d.get('name'),
10371            override_database=d.get('override_database'),
10372            password=d.get('password'),
10373            port=d.get('port'),
10374            port_override=d.get('port_override'),
10375            secret_store_id=d.get('secret_store_id'),
10376            tags=d.get('tags'),
10377            username=d.get('username'),
10378        )
Redshift( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
10251    def __init__(
10252        self,
10253        bind_interface=None,
10254        database=None,
10255        egress_filter=None,
10256        healthy=None,
10257        hostname=None,
10258        id=None,
10259        name=None,
10260        override_database=None,
10261        password=None,
10262        port=None,
10263        port_override=None,
10264        secret_store_id=None,
10265        tags=None,
10266        username=None,
10267    ):
10268        self.bind_interface = bind_interface if bind_interface is not None else ''
10269        '''
10270         Bind interface
10271        '''
10272        self.database = database if database is not None else ''
10273        '''
10274
10275        '''
10276        self.egress_filter = egress_filter if egress_filter is not None else ''
10277        '''
10278         A filter applied to the routing logic to pin datasource to nodes.
10279        '''
10280        self.healthy = healthy if healthy is not None else False
10281        '''
10282         True if the datasource is reachable and the credentials are valid.
10283        '''
10284        self.hostname = hostname if hostname is not None else ''
10285        '''
10286
10287        '''
10288        self.id = id if id is not None else ''
10289        '''
10290         Unique identifier of the Resource.
10291        '''
10292        self.name = name if name is not None else ''
10293        '''
10294         Unique human-readable name of the Resource.
10295        '''
10296        self.override_database = override_database if override_database is not None else False
10297        '''
10298
10299        '''
10300        self.password = password if password is not None else ''
10301        '''
10302
10303        '''
10304        self.port = port if port is not None else 0
10305        '''
10306
10307        '''
10308        self.port_override = port_override if port_override is not None else 0
10309        '''
10310
10311        '''
10312        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10313        '''
10314         ID of the secret store containing credentials for this resource, if any.
10315        '''
10316        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10317        '''
10318         Tags is a map of key, value pairs.
10319        '''
10320        self.username = username if username is not None else ''
10321        '''
10322
10323        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10343    def to_dict(self):
10344        return {
10345            'bind_interface': self.bind_interface,
10346            'database': self.database,
10347            'egress_filter': self.egress_filter,
10348            'healthy': self.healthy,
10349            'hostname': self.hostname,
10350            'id': self.id,
10351            'name': self.name,
10352            'override_database': self.override_database,
10353            'password': self.password,
10354            'port': self.port,
10355            'port_override': self.port_override,
10356            'secret_store_id': self.secret_store_id,
10357            'tags': self.tags,
10358            'username': self.username,
10359        }
@classmethod
def from_dict(cls, d)
10361    @classmethod
10362    def from_dict(cls, d):
10363        return cls(
10364            bind_interface=d.get('bind_interface'),
10365            database=d.get('database'),
10366            egress_filter=d.get('egress_filter'),
10367            healthy=d.get('healthy'),
10368            hostname=d.get('hostname'),
10369            id=d.get('id'),
10370            name=d.get('name'),
10371            override_database=d.get('override_database'),
10372            password=d.get('password'),
10373            port=d.get('port'),
10374            port_override=d.get('port_override'),
10375            secret_store_id=d.get('secret_store_id'),
10376            tags=d.get('tags'),
10377            username=d.get('username'),
10378        )
class Relay:
10381class Relay:
10382    '''
10383     Relay represents a StrongDM CLI installation running in relay mode.
10384    '''
10385    __slots__ = [
10386        'gateway_filter',
10387        'id',
10388        'name',
10389        'state',
10390        'tags',
10391    ]
10392
10393    def __init__(
10394        self,
10395        gateway_filter=None,
10396        id=None,
10397        name=None,
10398        state=None,
10399        tags=None,
10400    ):
10401        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
10402        '''
10403         GatewayFilter can be used to restrict the peering between relays and
10404         gateways.
10405        '''
10406        self.id = id if id is not None else ''
10407        '''
10408         Unique identifier of the Relay.
10409        '''
10410        self.name = name if name is not None else ''
10411        '''
10412         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
10413        '''
10414        self.state = state if state is not None else ''
10415        '''
10416         The current state of the relay. One of: "new", "verifying_restart",
10417         "awaiting_restart", "restarting", "started", "stopped", "dead",
10418         "unknown".
10419        '''
10420        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10421        '''
10422         Tags is a map of key, value pairs.
10423        '''
10424
10425    def __repr__(self):
10426        return '<sdm.Relay ' + \
10427            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
10428            'id: ' + repr(self.id) + ' ' +\
10429            'name: ' + repr(self.name) + ' ' +\
10430            'state: ' + repr(self.state) + ' ' +\
10431            'tags: ' + repr(self.tags) + ' ' +\
10432            '>'
10433
10434    def to_dict(self):
10435        return {
10436            'gateway_filter': self.gateway_filter,
10437            'id': self.id,
10438            'name': self.name,
10439            'state': self.state,
10440            'tags': self.tags,
10441        }
10442
10443    @classmethod
10444    def from_dict(cls, d):
10445        return cls(
10446            gateway_filter=d.get('gateway_filter'),
10447            id=d.get('id'),
10448            name=d.get('name'),
10449            state=d.get('state'),
10450            tags=d.get('tags'),
10451        )

Relay represents a StrongDM CLI installation running in relay mode.

Relay(gateway_filter=None, id=None, name=None, state=None, tags=None)
10393    def __init__(
10394        self,
10395        gateway_filter=None,
10396        id=None,
10397        name=None,
10398        state=None,
10399        tags=None,
10400    ):
10401        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
10402        '''
10403         GatewayFilter can be used to restrict the peering between relays and
10404         gateways.
10405        '''
10406        self.id = id if id is not None else ''
10407        '''
10408         Unique identifier of the Relay.
10409        '''
10410        self.name = name if name is not None else ''
10411        '''
10412         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
10413        '''
10414        self.state = state if state is not None else ''
10415        '''
10416         The current state of the relay. One of: "new", "verifying_restart",
10417         "awaiting_restart", "restarting", "started", "stopped", "dead",
10418         "unknown".
10419        '''
10420        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10421        '''
10422         Tags is a map of key, value pairs.
10423        '''
gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Relay.

name

Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the relay. One of: "new", "verifying_restart", "awaiting_restart", "restarting", "started", "stopped", "dead", "unknown".

tags

Tags is a map of key, value pairs.

def to_dict(self)
10434    def to_dict(self):
10435        return {
10436            'gateway_filter': self.gateway_filter,
10437            'id': self.id,
10438            'name': self.name,
10439            'state': self.state,
10440            'tags': self.tags,
10441        }
@classmethod
def from_dict(cls, d)
10443    @classmethod
10444    def from_dict(cls, d):
10445        return cls(
10446            gateway_filter=d.get('gateway_filter'),
10447            id=d.get('id'),
10448            name=d.get('name'),
10449            state=d.get('state'),
10450            tags=d.get('tags'),
10451        )
class RemoteIdentity:
10454class RemoteIdentity:
10455    '''
10456     RemoteIdentities define the username to be used for a specific account
10457     when connecting to a remote resource using that group.
10458    '''
10459    __slots__ = [
10460        'account_id',
10461        'id',
10462        'remote_identity_group_id',
10463        'username',
10464    ]
10465
10466    def __init__(
10467        self,
10468        account_id=None,
10469        id=None,
10470        remote_identity_group_id=None,
10471        username=None,
10472    ):
10473        self.account_id = account_id if account_id is not None else ''
10474        '''
10475         The account for this remote identity.
10476        '''
10477        self.id = id if id is not None else ''
10478        '''
10479         Unique identifier of the RemoteIdentity.
10480        '''
10481        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10482        '''
10483         The remote identity group.
10484        '''
10485        self.username = username if username is not None else ''
10486        '''
10487         The username to be used as the remote identity for this account.
10488        '''
10489
10490    def __repr__(self):
10491        return '<sdm.RemoteIdentity ' + \
10492            'account_id: ' + repr(self.account_id) + ' ' +\
10493            'id: ' + repr(self.id) + ' ' +\
10494            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10495            'username: ' + repr(self.username) + ' ' +\
10496            '>'
10497
10498    def to_dict(self):
10499        return {
10500            'account_id': self.account_id,
10501            'id': self.id,
10502            'remote_identity_group_id': self.remote_identity_group_id,
10503            'username': self.username,
10504        }
10505
10506    @classmethod
10507    def from_dict(cls, d):
10508        return cls(
10509            account_id=d.get('account_id'),
10510            id=d.get('id'),
10511            remote_identity_group_id=d.get('remote_identity_group_id'),
10512            username=d.get('username'),
10513        )

RemoteIdentities define the username to be used for a specific account when connecting to a remote resource using that group.

RemoteIdentity( account_id=None, id=None, remote_identity_group_id=None, username=None)
10466    def __init__(
10467        self,
10468        account_id=None,
10469        id=None,
10470        remote_identity_group_id=None,
10471        username=None,
10472    ):
10473        self.account_id = account_id if account_id is not None else ''
10474        '''
10475         The account for this remote identity.
10476        '''
10477        self.id = id if id is not None else ''
10478        '''
10479         Unique identifier of the RemoteIdentity.
10480        '''
10481        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10482        '''
10483         The remote identity group.
10484        '''
10485        self.username = username if username is not None else ''
10486        '''
10487         The username to be used as the remote identity for this account.
10488        '''
account_id

The account for this remote identity.

id

Unique identifier of the RemoteIdentity.

remote_identity_group_id

The remote identity group.

username

The username to be used as the remote identity for this account.

def to_dict(self)
10498    def to_dict(self):
10499        return {
10500            'account_id': self.account_id,
10501            'id': self.id,
10502            'remote_identity_group_id': self.remote_identity_group_id,
10503            'username': self.username,
10504        }
@classmethod
def from_dict(cls, d)
10506    @classmethod
10507    def from_dict(cls, d):
10508        return cls(
10509            account_id=d.get('account_id'),
10510            id=d.get('id'),
10511            remote_identity_group_id=d.get('remote_identity_group_id'),
10512            username=d.get('username'),
10513        )
class RemoteIdentityCreateResponse:
10516class RemoteIdentityCreateResponse:
10517    '''
10518     RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
10519    '''
10520    __slots__ = [
10521        'meta',
10522        'rate_limit',
10523        'remote_identity',
10524    ]
10525
10526    def __init__(
10527        self,
10528        meta=None,
10529        rate_limit=None,
10530        remote_identity=None,
10531    ):
10532        self.meta = meta if meta is not None else None
10533        '''
10534         Reserved for future use.
10535        '''
10536        self.rate_limit = rate_limit if rate_limit is not None else None
10537        '''
10538         Rate limit information.
10539        '''
10540        self.remote_identity = remote_identity if remote_identity is not None else None
10541        '''
10542         The created RemoteIdentity.
10543        '''
10544
10545    def __repr__(self):
10546        return '<sdm.RemoteIdentityCreateResponse ' + \
10547            'meta: ' + repr(self.meta) + ' ' +\
10548            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10549            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10550            '>'
10551
10552    def to_dict(self):
10553        return {
10554            'meta': self.meta,
10555            'rate_limit': self.rate_limit,
10556            'remote_identity': self.remote_identity,
10557        }
10558
10559    @classmethod
10560    def from_dict(cls, d):
10561        return cls(
10562            meta=d.get('meta'),
10563            rate_limit=d.get('rate_limit'),
10564            remote_identity=d.get('remote_identity'),
10565        )

RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.

RemoteIdentityCreateResponse(meta=None, rate_limit=None, remote_identity=None)
10526    def __init__(
10527        self,
10528        meta=None,
10529        rate_limit=None,
10530        remote_identity=None,
10531    ):
10532        self.meta = meta if meta is not None else None
10533        '''
10534         Reserved for future use.
10535        '''
10536        self.rate_limit = rate_limit if rate_limit is not None else None
10537        '''
10538         Rate limit information.
10539        '''
10540        self.remote_identity = remote_identity if remote_identity is not None else None
10541        '''
10542         The created RemoteIdentity.
10543        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The created RemoteIdentity.

def to_dict(self)
10552    def to_dict(self):
10553        return {
10554            'meta': self.meta,
10555            'rate_limit': self.rate_limit,
10556            'remote_identity': self.remote_identity,
10557        }
@classmethod
def from_dict(cls, d)
10559    @classmethod
10560    def from_dict(cls, d):
10561        return cls(
10562            meta=d.get('meta'),
10563            rate_limit=d.get('rate_limit'),
10564            remote_identity=d.get('remote_identity'),
10565        )
class RemoteIdentityDeleteResponse:
10568class RemoteIdentityDeleteResponse:
10569    '''
10570     RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
10571    '''
10572    __slots__ = [
10573        'meta',
10574        'rate_limit',
10575    ]
10576
10577    def __init__(
10578        self,
10579        meta=None,
10580        rate_limit=None,
10581    ):
10582        self.meta = meta if meta is not None else None
10583        '''
10584         Reserved for future use.
10585        '''
10586        self.rate_limit = rate_limit if rate_limit is not None else None
10587        '''
10588         Rate limit information.
10589        '''
10590
10591    def __repr__(self):
10592        return '<sdm.RemoteIdentityDeleteResponse ' + \
10593            'meta: ' + repr(self.meta) + ' ' +\
10594            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10595            '>'
10596
10597    def to_dict(self):
10598        return {
10599            'meta': self.meta,
10600            'rate_limit': self.rate_limit,
10601        }
10602
10603    @classmethod
10604    def from_dict(cls, d):
10605        return cls(
10606            meta=d.get('meta'),
10607            rate_limit=d.get('rate_limit'),
10608        )

RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.

RemoteIdentityDeleteResponse(meta=None, rate_limit=None)
10577    def __init__(
10578        self,
10579        meta=None,
10580        rate_limit=None,
10581    ):
10582        self.meta = meta if meta is not None else None
10583        '''
10584         Reserved for future use.
10585        '''
10586        self.rate_limit = rate_limit if rate_limit is not None else None
10587        '''
10588         Rate limit information.
10589        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10597    def to_dict(self):
10598        return {
10599            'meta': self.meta,
10600            'rate_limit': self.rate_limit,
10601        }
@classmethod
def from_dict(cls, d)
10603    @classmethod
10604    def from_dict(cls, d):
10605        return cls(
10606            meta=d.get('meta'),
10607            rate_limit=d.get('rate_limit'),
10608        )
class RemoteIdentityGetResponse:
10611class RemoteIdentityGetResponse:
10612    '''
10613     RemoteIdentityGetResponse returns a requested RemoteIdentity.
10614    '''
10615    __slots__ = [
10616        'meta',
10617        'rate_limit',
10618        'remote_identity',
10619    ]
10620
10621    def __init__(
10622        self,
10623        meta=None,
10624        rate_limit=None,
10625        remote_identity=None,
10626    ):
10627        self.meta = meta if meta is not None else None
10628        '''
10629         Reserved for future use.
10630        '''
10631        self.rate_limit = rate_limit if rate_limit is not None else None
10632        '''
10633         Rate limit information.
10634        '''
10635        self.remote_identity = remote_identity if remote_identity is not None else None
10636        '''
10637         The requested RemoteIdentity.
10638        '''
10639
10640    def __repr__(self):
10641        return '<sdm.RemoteIdentityGetResponse ' + \
10642            'meta: ' + repr(self.meta) + ' ' +\
10643            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10644            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10645            '>'
10646
10647    def to_dict(self):
10648        return {
10649            'meta': self.meta,
10650            'rate_limit': self.rate_limit,
10651            'remote_identity': self.remote_identity,
10652        }
10653
10654    @classmethod
10655    def from_dict(cls, d):
10656        return cls(
10657            meta=d.get('meta'),
10658            rate_limit=d.get('rate_limit'),
10659            remote_identity=d.get('remote_identity'),
10660        )

RemoteIdentityGetResponse returns a requested RemoteIdentity.

RemoteIdentityGetResponse(meta=None, rate_limit=None, remote_identity=None)
10621    def __init__(
10622        self,
10623        meta=None,
10624        rate_limit=None,
10625        remote_identity=None,
10626    ):
10627        self.meta = meta if meta is not None else None
10628        '''
10629         Reserved for future use.
10630        '''
10631        self.rate_limit = rate_limit if rate_limit is not None else None
10632        '''
10633         Rate limit information.
10634        '''
10635        self.remote_identity = remote_identity if remote_identity is not None else None
10636        '''
10637         The requested RemoteIdentity.
10638        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The requested RemoteIdentity.

def to_dict(self)
10647    def to_dict(self):
10648        return {
10649            'meta': self.meta,
10650            'rate_limit': self.rate_limit,
10651            'remote_identity': self.remote_identity,
10652        }
@classmethod
def from_dict(cls, d)
10654    @classmethod
10655    def from_dict(cls, d):
10656        return cls(
10657            meta=d.get('meta'),
10658            rate_limit=d.get('rate_limit'),
10659            remote_identity=d.get('remote_identity'),
10660        )
class RemoteIdentityGroup:
10663class RemoteIdentityGroup:
10664    '''
10665     A RemoteIdentityGroup defines a group of remote identities.
10666    '''
10667    __slots__ = [
10668        'id',
10669        'name',
10670    ]
10671
10672    def __init__(
10673        self,
10674        id=None,
10675        name=None,
10676    ):
10677        self.id = id if id is not None else ''
10678        '''
10679         Unique identifier of the RemoteIdentityGroup.
10680        '''
10681        self.name = name if name is not None else ''
10682        '''
10683         Unique human-readable name of the RemoteIdentityGroup.
10684        '''
10685
10686    def __repr__(self):
10687        return '<sdm.RemoteIdentityGroup ' + \
10688            'id: ' + repr(self.id) + ' ' +\
10689            'name: ' + repr(self.name) + ' ' +\
10690            '>'
10691
10692    def to_dict(self):
10693        return {
10694            'id': self.id,
10695            'name': self.name,
10696        }
10697
10698    @classmethod
10699    def from_dict(cls, d):
10700        return cls(
10701            id=d.get('id'),
10702            name=d.get('name'),
10703        )

A RemoteIdentityGroup defines a group of remote identities.

RemoteIdentityGroup(id=None, name=None)
10672    def __init__(
10673        self,
10674        id=None,
10675        name=None,
10676    ):
10677        self.id = id if id is not None else ''
10678        '''
10679         Unique identifier of the RemoteIdentityGroup.
10680        '''
10681        self.name = name if name is not None else ''
10682        '''
10683         Unique human-readable name of the RemoteIdentityGroup.
10684        '''
id

Unique identifier of the RemoteIdentityGroup.

name

Unique human-readable name of the RemoteIdentityGroup.

def to_dict(self)
10692    def to_dict(self):
10693        return {
10694            'id': self.id,
10695            'name': self.name,
10696        }
@classmethod
def from_dict(cls, d)
10698    @classmethod
10699    def from_dict(cls, d):
10700        return cls(
10701            id=d.get('id'),
10702            name=d.get('name'),
10703        )
class RemoteIdentityGroupGetResponse:
10706class RemoteIdentityGroupGetResponse:
10707    '''
10708     RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
10709    '''
10710    __slots__ = [
10711        'meta',
10712        'rate_limit',
10713        'remote_identity_group',
10714    ]
10715
10716    def __init__(
10717        self,
10718        meta=None,
10719        rate_limit=None,
10720        remote_identity_group=None,
10721    ):
10722        self.meta = meta if meta is not None else None
10723        '''
10724         Reserved for future use.
10725        '''
10726        self.rate_limit = rate_limit if rate_limit is not None else None
10727        '''
10728         Rate limit information.
10729        '''
10730        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10731        '''
10732         The requested RemoteIdentityGroup.
10733        '''
10734
10735    def __repr__(self):
10736        return '<sdm.RemoteIdentityGroupGetResponse ' + \
10737            'meta: ' + repr(self.meta) + ' ' +\
10738            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10739            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
10740            '>'
10741
10742    def to_dict(self):
10743        return {
10744            'meta': self.meta,
10745            'rate_limit': self.rate_limit,
10746            'remote_identity_group': self.remote_identity_group,
10747        }
10748
10749    @classmethod
10750    def from_dict(cls, d):
10751        return cls(
10752            meta=d.get('meta'),
10753            rate_limit=d.get('rate_limit'),
10754            remote_identity_group=d.get('remote_identity_group'),
10755        )

RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.

RemoteIdentityGroupGetResponse(meta=None, rate_limit=None, remote_identity_group=None)
10716    def __init__(
10717        self,
10718        meta=None,
10719        rate_limit=None,
10720        remote_identity_group=None,
10721    ):
10722        self.meta = meta if meta is not None else None
10723        '''
10724         Reserved for future use.
10725        '''
10726        self.rate_limit = rate_limit if rate_limit is not None else None
10727        '''
10728         Rate limit information.
10729        '''
10730        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10731        '''
10732         The requested RemoteIdentityGroup.
10733        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity_group

The requested RemoteIdentityGroup.

def to_dict(self)
10742    def to_dict(self):
10743        return {
10744            'meta': self.meta,
10745            'rate_limit': self.rate_limit,
10746            'remote_identity_group': self.remote_identity_group,
10747        }
@classmethod
def from_dict(cls, d)
10749    @classmethod
10750    def from_dict(cls, d):
10751        return cls(
10752            meta=d.get('meta'),
10753            rate_limit=d.get('rate_limit'),
10754            remote_identity_group=d.get('remote_identity_group'),
10755        )
class RemoteIdentityUpdateResponse:
10758class RemoteIdentityUpdateResponse:
10759    '''
10760     RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
10761     a RemoteIdentityUpdateRequest.
10762    '''
10763    __slots__ = [
10764        'meta',
10765        'rate_limit',
10766        'remote_identity',
10767    ]
10768
10769    def __init__(
10770        self,
10771        meta=None,
10772        rate_limit=None,
10773        remote_identity=None,
10774    ):
10775        self.meta = meta if meta is not None else None
10776        '''
10777         Reserved for future use.
10778        '''
10779        self.rate_limit = rate_limit if rate_limit is not None else None
10780        '''
10781         Rate limit information.
10782        '''
10783        self.remote_identity = remote_identity if remote_identity is not None else None
10784        '''
10785         The updated RemoteIdentity.
10786        '''
10787
10788    def __repr__(self):
10789        return '<sdm.RemoteIdentityUpdateResponse ' + \
10790            'meta: ' + repr(self.meta) + ' ' +\
10791            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10792            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10793            '>'
10794
10795    def to_dict(self):
10796        return {
10797            'meta': self.meta,
10798            'rate_limit': self.rate_limit,
10799            'remote_identity': self.remote_identity,
10800        }
10801
10802    @classmethod
10803    def from_dict(cls, d):
10804        return cls(
10805            meta=d.get('meta'),
10806            rate_limit=d.get('rate_limit'),
10807            remote_identity=d.get('remote_identity'),
10808        )

RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by a RemoteIdentityUpdateRequest.

RemoteIdentityUpdateResponse(meta=None, rate_limit=None, remote_identity=None)
10769    def __init__(
10770        self,
10771        meta=None,
10772        rate_limit=None,
10773        remote_identity=None,
10774    ):
10775        self.meta = meta if meta is not None else None
10776        '''
10777         Reserved for future use.
10778        '''
10779        self.rate_limit = rate_limit if rate_limit is not None else None
10780        '''
10781         Rate limit information.
10782        '''
10783        self.remote_identity = remote_identity if remote_identity is not None else None
10784        '''
10785         The updated RemoteIdentity.
10786        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The updated RemoteIdentity.

def to_dict(self)
10795    def to_dict(self):
10796        return {
10797            'meta': self.meta,
10798            'rate_limit': self.rate_limit,
10799            'remote_identity': self.remote_identity,
10800        }
@classmethod
def from_dict(cls, d)
10802    @classmethod
10803    def from_dict(cls, d):
10804        return cls(
10805            meta=d.get('meta'),
10806            rate_limit=d.get('rate_limit'),
10807            remote_identity=d.get('remote_identity'),
10808        )
class ResourceCreateResponse:
10811class ResourceCreateResponse:
10812    '''
10813     ResourceCreateResponse reports how the Resources were created in the system.
10814    '''
10815    __slots__ = [
10816        'meta',
10817        'rate_limit',
10818        'resource',
10819    ]
10820
10821    def __init__(
10822        self,
10823        meta=None,
10824        rate_limit=None,
10825        resource=None,
10826    ):
10827        self.meta = meta if meta is not None else None
10828        '''
10829         Reserved for future use.
10830        '''
10831        self.rate_limit = rate_limit if rate_limit is not None else None
10832        '''
10833         Rate limit information.
10834        '''
10835        self.resource = resource if resource is not None else None
10836        '''
10837         The created Resource.
10838        '''
10839
10840    def __repr__(self):
10841        return '<sdm.ResourceCreateResponse ' + \
10842            'meta: ' + repr(self.meta) + ' ' +\
10843            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10844            'resource: ' + repr(self.resource) + ' ' +\
10845            '>'
10846
10847    def to_dict(self):
10848        return {
10849            'meta': self.meta,
10850            'rate_limit': self.rate_limit,
10851            'resource': self.resource,
10852        }
10853
10854    @classmethod
10855    def from_dict(cls, d):
10856        return cls(
10857            meta=d.get('meta'),
10858            rate_limit=d.get('rate_limit'),
10859            resource=d.get('resource'),
10860        )

ResourceCreateResponse reports how the Resources were created in the system.

ResourceCreateResponse(meta=None, rate_limit=None, resource=None)
10821    def __init__(
10822        self,
10823        meta=None,
10824        rate_limit=None,
10825        resource=None,
10826    ):
10827        self.meta = meta if meta is not None else None
10828        '''
10829         Reserved for future use.
10830        '''
10831        self.rate_limit = rate_limit if rate_limit is not None else None
10832        '''
10833         Rate limit information.
10834        '''
10835        self.resource = resource if resource is not None else None
10836        '''
10837         The created Resource.
10838        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The created Resource.

def to_dict(self)
10847    def to_dict(self):
10848        return {
10849            'meta': self.meta,
10850            'rate_limit': self.rate_limit,
10851            'resource': self.resource,
10852        }
@classmethod
def from_dict(cls, d)
10854    @classmethod
10855    def from_dict(cls, d):
10856        return cls(
10857            meta=d.get('meta'),
10858            rate_limit=d.get('rate_limit'),
10859            resource=d.get('resource'),
10860        )
class ResourceDeleteResponse:
10863class ResourceDeleteResponse:
10864    '''
10865     ResourceDeleteResponse returns information about a Resource that was deleted.
10866    '''
10867    __slots__ = [
10868        'meta',
10869        'rate_limit',
10870    ]
10871
10872    def __init__(
10873        self,
10874        meta=None,
10875        rate_limit=None,
10876    ):
10877        self.meta = meta if meta is not None else None
10878        '''
10879         Reserved for future use.
10880        '''
10881        self.rate_limit = rate_limit if rate_limit is not None else None
10882        '''
10883         Rate limit information.
10884        '''
10885
10886    def __repr__(self):
10887        return '<sdm.ResourceDeleteResponse ' + \
10888            'meta: ' + repr(self.meta) + ' ' +\
10889            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10890            '>'
10891
10892    def to_dict(self):
10893        return {
10894            'meta': self.meta,
10895            'rate_limit': self.rate_limit,
10896        }
10897
10898    @classmethod
10899    def from_dict(cls, d):
10900        return cls(
10901            meta=d.get('meta'),
10902            rate_limit=d.get('rate_limit'),
10903        )

ResourceDeleteResponse returns information about a Resource that was deleted.

ResourceDeleteResponse(meta=None, rate_limit=None)
10872    def __init__(
10873        self,
10874        meta=None,
10875        rate_limit=None,
10876    ):
10877        self.meta = meta if meta is not None else None
10878        '''
10879         Reserved for future use.
10880        '''
10881        self.rate_limit = rate_limit if rate_limit is not None else None
10882        '''
10883         Rate limit information.
10884        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10892    def to_dict(self):
10893        return {
10894            'meta': self.meta,
10895            'rate_limit': self.rate_limit,
10896        }
@classmethod
def from_dict(cls, d)
10898    @classmethod
10899    def from_dict(cls, d):
10900        return cls(
10901            meta=d.get('meta'),
10902            rate_limit=d.get('rate_limit'),
10903        )
class ResourceGetResponse:
10906class ResourceGetResponse:
10907    '''
10908     ResourceGetResponse returns a requested Resource.
10909    '''
10910    __slots__ = [
10911        'meta',
10912        'rate_limit',
10913        'resource',
10914    ]
10915
10916    def __init__(
10917        self,
10918        meta=None,
10919        rate_limit=None,
10920        resource=None,
10921    ):
10922        self.meta = meta if meta is not None else None
10923        '''
10924         Reserved for future use.
10925        '''
10926        self.rate_limit = rate_limit if rate_limit is not None else None
10927        '''
10928         Rate limit information.
10929        '''
10930        self.resource = resource if resource is not None else None
10931        '''
10932         The requested Resource.
10933        '''
10934
10935    def __repr__(self):
10936        return '<sdm.ResourceGetResponse ' + \
10937            'meta: ' + repr(self.meta) + ' ' +\
10938            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10939            'resource: ' + repr(self.resource) + ' ' +\
10940            '>'
10941
10942    def to_dict(self):
10943        return {
10944            'meta': self.meta,
10945            'rate_limit': self.rate_limit,
10946            'resource': self.resource,
10947        }
10948
10949    @classmethod
10950    def from_dict(cls, d):
10951        return cls(
10952            meta=d.get('meta'),
10953            rate_limit=d.get('rate_limit'),
10954            resource=d.get('resource'),
10955        )

ResourceGetResponse returns a requested Resource.

ResourceGetResponse(meta=None, rate_limit=None, resource=None)
10916    def __init__(
10917        self,
10918        meta=None,
10919        rate_limit=None,
10920        resource=None,
10921    ):
10922        self.meta = meta if meta is not None else None
10923        '''
10924         Reserved for future use.
10925        '''
10926        self.rate_limit = rate_limit if rate_limit is not None else None
10927        '''
10928         Rate limit information.
10929        '''
10930        self.resource = resource if resource is not None else None
10931        '''
10932         The requested Resource.
10933        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The requested Resource.

def to_dict(self)
10942    def to_dict(self):
10943        return {
10944            'meta': self.meta,
10945            'rate_limit': self.rate_limit,
10946            'resource': self.resource,
10947        }
@classmethod
def from_dict(cls, d)
10949    @classmethod
10950    def from_dict(cls, d):
10951        return cls(
10952            meta=d.get('meta'),
10953            rate_limit=d.get('rate_limit'),
10954            resource=d.get('resource'),
10955        )
class ResourceUpdateResponse:
10958class ResourceUpdateResponse:
10959    '''
10960     ResourceUpdateResponse returns the fields of a Resource after it has been updated by
10961     a ResourceUpdateRequest.
10962    '''
10963    __slots__ = [
10964        'meta',
10965        'rate_limit',
10966        'resource',
10967    ]
10968
10969    def __init__(
10970        self,
10971        meta=None,
10972        rate_limit=None,
10973        resource=None,
10974    ):
10975        self.meta = meta if meta is not None else None
10976        '''
10977         Reserved for future use.
10978        '''
10979        self.rate_limit = rate_limit if rate_limit is not None else None
10980        '''
10981         Rate limit information.
10982        '''
10983        self.resource = resource if resource is not None else None
10984        '''
10985         The updated Resource.
10986        '''
10987
10988    def __repr__(self):
10989        return '<sdm.ResourceUpdateResponse ' + \
10990            'meta: ' + repr(self.meta) + ' ' +\
10991            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10992            'resource: ' + repr(self.resource) + ' ' +\
10993            '>'
10994
10995    def to_dict(self):
10996        return {
10997            'meta': self.meta,
10998            'rate_limit': self.rate_limit,
10999            'resource': self.resource,
11000        }
11001
11002    @classmethod
11003    def from_dict(cls, d):
11004        return cls(
11005            meta=d.get('meta'),
11006            rate_limit=d.get('rate_limit'),
11007            resource=d.get('resource'),
11008        )

ResourceUpdateResponse returns the fields of a Resource after it has been updated by a ResourceUpdateRequest.

ResourceUpdateResponse(meta=None, rate_limit=None, resource=None)
10969    def __init__(
10970        self,
10971        meta=None,
10972        rate_limit=None,
10973        resource=None,
10974    ):
10975        self.meta = meta if meta is not None else None
10976        '''
10977         Reserved for future use.
10978        '''
10979        self.rate_limit = rate_limit if rate_limit is not None else None
10980        '''
10981         Rate limit information.
10982        '''
10983        self.resource = resource if resource is not None else None
10984        '''
10985         The updated Resource.
10986        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The updated Resource.

def to_dict(self)
10995    def to_dict(self):
10996        return {
10997            'meta': self.meta,
10998            'rate_limit': self.rate_limit,
10999            'resource': self.resource,
11000        }
@classmethod
def from_dict(cls, d)
11002    @classmethod
11003    def from_dict(cls, d):
11004        return cls(
11005            meta=d.get('meta'),
11006            rate_limit=d.get('rate_limit'),
11007            resource=d.get('resource'),
11008        )
class Role:
11011class Role:
11012    '''
11013     A Role has a list of access rules which determine which Resources the members
11014     of the Role have access to. An Account can be a member of multiple Roles via
11015     AccountAttachments.
11016    '''
11017    __slots__ = [
11018        'access_rules',
11019        'id',
11020        'name',
11021        'tags',
11022    ]
11023
11024    def __init__(
11025        self,
11026        access_rules=None,
11027        id=None,
11028        name=None,
11029        tags=None,
11030    ):
11031        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
11032        )
11033        '''
11034         AccessRules is a list of access rules defining the resources this Role has access to.
11035        '''
11036        self.id = id if id is not None else ''
11037        '''
11038         Unique identifier of the Role.
11039        '''
11040        self.name = name if name is not None else ''
11041        '''
11042         Unique human-readable name of the Role.
11043        '''
11044        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11045        '''
11046         Tags is a map of key, value pairs.
11047        '''
11048
11049    def __repr__(self):
11050        return '<sdm.Role ' + \
11051            'access_rules: ' + repr(self.access_rules) + ' ' +\
11052            'id: ' + repr(self.id) + ' ' +\
11053            'name: ' + repr(self.name) + ' ' +\
11054            'tags: ' + repr(self.tags) + ' ' +\
11055            '>'
11056
11057    def to_dict(self):
11058        return {
11059            'access_rules': self.access_rules,
11060            'id': self.id,
11061            'name': self.name,
11062            'tags': self.tags,
11063        }
11064
11065    @classmethod
11066    def from_dict(cls, d):
11067        return cls(
11068            access_rules=d.get('access_rules'),
11069            id=d.get('id'),
11070            name=d.get('name'),
11071            tags=d.get('tags'),
11072        )

A Role has a list of access rules which determine which Resources the members of the Role have access to. An Account can be a member of multiple Roles via AccountAttachments.

Role(access_rules=None, id=None, name=None, tags=None)
11024    def __init__(
11025        self,
11026        access_rules=None,
11027        id=None,
11028        name=None,
11029        tags=None,
11030    ):
11031        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
11032        )
11033        '''
11034         AccessRules is a list of access rules defining the resources this Role has access to.
11035        '''
11036        self.id = id if id is not None else ''
11037        '''
11038         Unique identifier of the Role.
11039        '''
11040        self.name = name if name is not None else ''
11041        '''
11042         Unique human-readable name of the Role.
11043        '''
11044        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11045        '''
11046         Tags is a map of key, value pairs.
11047        '''
access_rules

AccessRules is a list of access rules defining the resources this Role has access to.

id

Unique identifier of the Role.

name

Unique human-readable name of the Role.

tags

Tags is a map of key, value pairs.

def to_dict(self)
11057    def to_dict(self):
11058        return {
11059            'access_rules': self.access_rules,
11060            'id': self.id,
11061            'name': self.name,
11062            'tags': self.tags,
11063        }
@classmethod
def from_dict(cls, d)
11065    @classmethod
11066    def from_dict(cls, d):
11067        return cls(
11068            access_rules=d.get('access_rules'),
11069            id=d.get('id'),
11070            name=d.get('name'),
11071            tags=d.get('tags'),
11072        )
class RoleCreateResponse:
11075class RoleCreateResponse:
11076    '''
11077     RoleCreateResponse reports how the Roles were created in the system. It can
11078     communicate partial successes or failures.
11079    '''
11080    __slots__ = [
11081        'meta',
11082        'rate_limit',
11083        'role',
11084    ]
11085
11086    def __init__(
11087        self,
11088        meta=None,
11089        rate_limit=None,
11090        role=None,
11091    ):
11092        self.meta = meta if meta is not None else None
11093        '''
11094         Reserved for future use.
11095        '''
11096        self.rate_limit = rate_limit if rate_limit is not None else None
11097        '''
11098         Rate limit information.
11099        '''
11100        self.role = role if role is not None else None
11101        '''
11102         The created Role.
11103        '''
11104
11105    def __repr__(self):
11106        return '<sdm.RoleCreateResponse ' + \
11107            'meta: ' + repr(self.meta) + ' ' +\
11108            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11109            'role: ' + repr(self.role) + ' ' +\
11110            '>'
11111
11112    def to_dict(self):
11113        return {
11114            'meta': self.meta,
11115            'rate_limit': self.rate_limit,
11116            'role': self.role,
11117        }
11118
11119    @classmethod
11120    def from_dict(cls, d):
11121        return cls(
11122            meta=d.get('meta'),
11123            rate_limit=d.get('rate_limit'),
11124            role=d.get('role'),
11125        )

RoleCreateResponse reports how the Roles were created in the system. It can communicate partial successes or failures.

RoleCreateResponse(meta=None, rate_limit=None, role=None)
11086    def __init__(
11087        self,
11088        meta=None,
11089        rate_limit=None,
11090        role=None,
11091    ):
11092        self.meta = meta if meta is not None else None
11093        '''
11094         Reserved for future use.
11095        '''
11096        self.rate_limit = rate_limit if rate_limit is not None else None
11097        '''
11098         Rate limit information.
11099        '''
11100        self.role = role if role is not None else None
11101        '''
11102         The created Role.
11103        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The created Role.

def to_dict(self)
11112    def to_dict(self):
11113        return {
11114            'meta': self.meta,
11115            'rate_limit': self.rate_limit,
11116            'role': self.role,
11117        }
@classmethod
def from_dict(cls, d)
11119    @classmethod
11120    def from_dict(cls, d):
11121        return cls(
11122            meta=d.get('meta'),
11123            rate_limit=d.get('rate_limit'),
11124            role=d.get('role'),
11125        )
class RoleDeleteResponse:
11128class RoleDeleteResponse:
11129    '''
11130     RoleDeleteResponse returns information about a Role that was deleted.
11131    '''
11132    __slots__ = [
11133        'meta',
11134        'rate_limit',
11135    ]
11136
11137    def __init__(
11138        self,
11139        meta=None,
11140        rate_limit=None,
11141    ):
11142        self.meta = meta if meta is not None else None
11143        '''
11144         Reserved for future use.
11145        '''
11146        self.rate_limit = rate_limit if rate_limit is not None else None
11147        '''
11148         Rate limit information.
11149        '''
11150
11151    def __repr__(self):
11152        return '<sdm.RoleDeleteResponse ' + \
11153            'meta: ' + repr(self.meta) + ' ' +\
11154            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11155            '>'
11156
11157    def to_dict(self):
11158        return {
11159            'meta': self.meta,
11160            'rate_limit': self.rate_limit,
11161        }
11162
11163    @classmethod
11164    def from_dict(cls, d):
11165        return cls(
11166            meta=d.get('meta'),
11167            rate_limit=d.get('rate_limit'),
11168        )

RoleDeleteResponse returns information about a Role that was deleted.

RoleDeleteResponse(meta=None, rate_limit=None)
11137    def __init__(
11138        self,
11139        meta=None,
11140        rate_limit=None,
11141    ):
11142        self.meta = meta if meta is not None else None
11143        '''
11144         Reserved for future use.
11145        '''
11146        self.rate_limit = rate_limit if rate_limit is not None else None
11147        '''
11148         Rate limit information.
11149        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
11157    def to_dict(self):
11158        return {
11159            'meta': self.meta,
11160            'rate_limit': self.rate_limit,
11161        }
@classmethod
def from_dict(cls, d)
11163    @classmethod
11164    def from_dict(cls, d):
11165        return cls(
11166            meta=d.get('meta'),
11167            rate_limit=d.get('rate_limit'),
11168        )
class RoleGetResponse:
11171class RoleGetResponse:
11172    '''
11173     RoleGetResponse returns a requested Role.
11174    '''
11175    __slots__ = [
11176        'meta',
11177        'rate_limit',
11178        'role',
11179    ]
11180
11181    def __init__(
11182        self,
11183        meta=None,
11184        rate_limit=None,
11185        role=None,
11186    ):
11187        self.meta = meta if meta is not None else None
11188        '''
11189         Reserved for future use.
11190        '''
11191        self.rate_limit = rate_limit if rate_limit is not None else None
11192        '''
11193         Rate limit information.
11194        '''
11195        self.role = role if role is not None else None
11196        '''
11197         The requested Role.
11198        '''
11199
11200    def __repr__(self):
11201        return '<sdm.RoleGetResponse ' + \
11202            'meta: ' + repr(self.meta) + ' ' +\
11203            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11204            'role: ' + repr(self.role) + ' ' +\
11205            '>'
11206
11207    def to_dict(self):
11208        return {
11209            'meta': self.meta,
11210            'rate_limit': self.rate_limit,
11211            'role': self.role,
11212        }
11213
11214    @classmethod
11215    def from_dict(cls, d):
11216        return cls(
11217            meta=d.get('meta'),
11218            rate_limit=d.get('rate_limit'),
11219            role=d.get('role'),
11220        )

RoleGetResponse returns a requested Role.

RoleGetResponse(meta=None, rate_limit=None, role=None)
11181    def __init__(
11182        self,
11183        meta=None,
11184        rate_limit=None,
11185        role=None,
11186    ):
11187        self.meta = meta if meta is not None else None
11188        '''
11189         Reserved for future use.
11190        '''
11191        self.rate_limit = rate_limit if rate_limit is not None else None
11192        '''
11193         Rate limit information.
11194        '''
11195        self.role = role if role is not None else None
11196        '''
11197         The requested Role.
11198        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The requested Role.

def to_dict(self)
11207    def to_dict(self):
11208        return {
11209            'meta': self.meta,
11210            'rate_limit': self.rate_limit,
11211            'role': self.role,
11212        }
@classmethod
def from_dict(cls, d)
11214    @classmethod
11215    def from_dict(cls, d):
11216        return cls(
11217            meta=d.get('meta'),
11218            rate_limit=d.get('rate_limit'),
11219            role=d.get('role'),
11220        )
class RoleUpdateResponse:
11223class RoleUpdateResponse:
11224    '''
11225     RoleUpdateResponse returns the fields of a Role after it has been updated by
11226     a RoleUpdateRequest.
11227    '''
11228    __slots__ = [
11229        'meta',
11230        'rate_limit',
11231        'role',
11232    ]
11233
11234    def __init__(
11235        self,
11236        meta=None,
11237        rate_limit=None,
11238        role=None,
11239    ):
11240        self.meta = meta if meta is not None else None
11241        '''
11242         Reserved for future use.
11243        '''
11244        self.rate_limit = rate_limit if rate_limit is not None else None
11245        '''
11246         Rate limit information.
11247        '''
11248        self.role = role if role is not None else None
11249        '''
11250         The updated Role.
11251        '''
11252
11253    def __repr__(self):
11254        return '<sdm.RoleUpdateResponse ' + \
11255            'meta: ' + repr(self.meta) + ' ' +\
11256            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11257            'role: ' + repr(self.role) + ' ' +\
11258            '>'
11259
11260    def to_dict(self):
11261        return {
11262            'meta': self.meta,
11263            'rate_limit': self.rate_limit,
11264            'role': self.role,
11265        }
11266
11267    @classmethod
11268    def from_dict(cls, d):
11269        return cls(
11270            meta=d.get('meta'),
11271            rate_limit=d.get('rate_limit'),
11272            role=d.get('role'),
11273        )

RoleUpdateResponse returns the fields of a Role after it has been updated by a RoleUpdateRequest.

RoleUpdateResponse(meta=None, rate_limit=None, role=None)
11234    def __init__(
11235        self,
11236        meta=None,
11237        rate_limit=None,
11238        role=None,
11239    ):
11240        self.meta = meta if meta is not None else None
11241        '''
11242         Reserved for future use.
11243        '''
11244        self.rate_limit = rate_limit if rate_limit is not None else None
11245        '''
11246         Rate limit information.
11247        '''
11248        self.role = role if role is not None else None
11249        '''
11250         The updated Role.
11251        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The updated Role.

def to_dict(self)
11260    def to_dict(self):
11261        return {
11262            'meta': self.meta,
11263            'rate_limit': self.rate_limit,
11264            'role': self.role,
11265        }
@classmethod
def from_dict(cls, d)
11267    @classmethod
11268    def from_dict(cls, d):
11269        return cls(
11270            meta=d.get('meta'),
11271            rate_limit=d.get('rate_limit'),
11272            role=d.get('role'),
11273        )
class SQLServer:
11276class SQLServer:
11277    '''
11278
11279    '''
11280    __slots__ = [
11281        'bind_interface',
11282        'database',
11283        'egress_filter',
11284        'healthy',
11285        'hostname',
11286        'id',
11287        'name',
11288        'override_database',
11289        'password',
11290        'port',
11291        'port_override',
11292        'schema',
11293        'secret_store_id',
11294        'tags',
11295        'username',
11296    ]
11297
11298    def __init__(
11299        self,
11300        bind_interface=None,
11301        database=None,
11302        egress_filter=None,
11303        healthy=None,
11304        hostname=None,
11305        id=None,
11306        name=None,
11307        override_database=None,
11308        password=None,
11309        port=None,
11310        port_override=None,
11311        schema=None,
11312        secret_store_id=None,
11313        tags=None,
11314        username=None,
11315    ):
11316        self.bind_interface = bind_interface if bind_interface is not None else ''
11317        '''
11318         Bind interface
11319        '''
11320        self.database = database if database is not None else ''
11321        '''
11322
11323        '''
11324        self.egress_filter = egress_filter if egress_filter is not None else ''
11325        '''
11326         A filter applied to the routing logic to pin datasource to nodes.
11327        '''
11328        self.healthy = healthy if healthy is not None else False
11329        '''
11330         True if the datasource is reachable and the credentials are valid.
11331        '''
11332        self.hostname = hostname if hostname is not None else ''
11333        '''
11334
11335        '''
11336        self.id = id if id is not None else ''
11337        '''
11338         Unique identifier of the Resource.
11339        '''
11340        self.name = name if name is not None else ''
11341        '''
11342         Unique human-readable name of the Resource.
11343        '''
11344        self.override_database = override_database if override_database is not None else False
11345        '''
11346
11347        '''
11348        self.password = password if password is not None else ''
11349        '''
11350
11351        '''
11352        self.port = port if port is not None else 0
11353        '''
11354
11355        '''
11356        self.port_override = port_override if port_override is not None else 0
11357        '''
11358
11359        '''
11360        self.schema = schema if schema is not None else ''
11361        '''
11362
11363        '''
11364        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11365        '''
11366         ID of the secret store containing credentials for this resource, if any.
11367        '''
11368        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11369        '''
11370         Tags is a map of key, value pairs.
11371        '''
11372        self.username = username if username is not None else ''
11373        '''
11374
11375        '''
11376
11377    def __repr__(self):
11378        return '<sdm.SQLServer ' + \
11379            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11380            'database: ' + repr(self.database) + ' ' +\
11381            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11382            'healthy: ' + repr(self.healthy) + ' ' +\
11383            'hostname: ' + repr(self.hostname) + ' ' +\
11384            'id: ' + repr(self.id) + ' ' +\
11385            'name: ' + repr(self.name) + ' ' +\
11386            'override_database: ' + repr(self.override_database) + ' ' +\
11387            'password: ' + repr(self.password) + ' ' +\
11388            'port: ' + repr(self.port) + ' ' +\
11389            'port_override: ' + repr(self.port_override) + ' ' +\
11390            'schema: ' + repr(self.schema) + ' ' +\
11391            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11392            'tags: ' + repr(self.tags) + ' ' +\
11393            'username: ' + repr(self.username) + ' ' +\
11394            '>'
11395
11396    def to_dict(self):
11397        return {
11398            'bind_interface': self.bind_interface,
11399            'database': self.database,
11400            'egress_filter': self.egress_filter,
11401            'healthy': self.healthy,
11402            'hostname': self.hostname,
11403            'id': self.id,
11404            'name': self.name,
11405            'override_database': self.override_database,
11406            'password': self.password,
11407            'port': self.port,
11408            'port_override': self.port_override,
11409            'schema': self.schema,
11410            'secret_store_id': self.secret_store_id,
11411            'tags': self.tags,
11412            'username': self.username,
11413        }
11414
11415    @classmethod
11416    def from_dict(cls, d):
11417        return cls(
11418            bind_interface=d.get('bind_interface'),
11419            database=d.get('database'),
11420            egress_filter=d.get('egress_filter'),
11421            healthy=d.get('healthy'),
11422            hostname=d.get('hostname'),
11423            id=d.get('id'),
11424            name=d.get('name'),
11425            override_database=d.get('override_database'),
11426            password=d.get('password'),
11427            port=d.get('port'),
11428            port_override=d.get('port_override'),
11429            schema=d.get('schema'),
11430            secret_store_id=d.get('secret_store_id'),
11431            tags=d.get('tags'),
11432            username=d.get('username'),
11433        )
SQLServer( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
11298    def __init__(
11299        self,
11300        bind_interface=None,
11301        database=None,
11302        egress_filter=None,
11303        healthy=None,
11304        hostname=None,
11305        id=None,
11306        name=None,
11307        override_database=None,
11308        password=None,
11309        port=None,
11310        port_override=None,
11311        schema=None,
11312        secret_store_id=None,
11313        tags=None,
11314        username=None,
11315    ):
11316        self.bind_interface = bind_interface if bind_interface is not None else ''
11317        '''
11318         Bind interface
11319        '''
11320        self.database = database if database is not None else ''
11321        '''
11322
11323        '''
11324        self.egress_filter = egress_filter if egress_filter is not None else ''
11325        '''
11326         A filter applied to the routing logic to pin datasource to nodes.
11327        '''
11328        self.healthy = healthy if healthy is not None else False
11329        '''
11330         True if the datasource is reachable and the credentials are valid.
11331        '''
11332        self.hostname = hostname if hostname is not None else ''
11333        '''
11334
11335        '''
11336        self.id = id if id is not None else ''
11337        '''
11338         Unique identifier of the Resource.
11339        '''
11340        self.name = name if name is not None else ''
11341        '''
11342         Unique human-readable name of the Resource.
11343        '''
11344        self.override_database = override_database if override_database is not None else False
11345        '''
11346
11347        '''
11348        self.password = password if password is not None else ''
11349        '''
11350
11351        '''
11352        self.port = port if port is not None else 0
11353        '''
11354
11355        '''
11356        self.port_override = port_override if port_override is not None else 0
11357        '''
11358
11359        '''
11360        self.schema = schema if schema is not None else ''
11361        '''
11362
11363        '''
11364        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11365        '''
11366         ID of the secret store containing credentials for this resource, if any.
11367        '''
11368        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11369        '''
11370         Tags is a map of key, value pairs.
11371        '''
11372        self.username = username if username is not None else ''
11373        '''
11374
11375        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11396    def to_dict(self):
11397        return {
11398            'bind_interface': self.bind_interface,
11399            'database': self.database,
11400            'egress_filter': self.egress_filter,
11401            'healthy': self.healthy,
11402            'hostname': self.hostname,
11403            'id': self.id,
11404            'name': self.name,
11405            'override_database': self.override_database,
11406            'password': self.password,
11407            'port': self.port,
11408            'port_override': self.port_override,
11409            'schema': self.schema,
11410            'secret_store_id': self.secret_store_id,
11411            'tags': self.tags,
11412            'username': self.username,
11413        }
@classmethod
def from_dict(cls, d)
11415    @classmethod
11416    def from_dict(cls, d):
11417        return cls(
11418            bind_interface=d.get('bind_interface'),
11419            database=d.get('database'),
11420            egress_filter=d.get('egress_filter'),
11421            healthy=d.get('healthy'),
11422            hostname=d.get('hostname'),
11423            id=d.get('id'),
11424            name=d.get('name'),
11425            override_database=d.get('override_database'),
11426            password=d.get('password'),
11427            port=d.get('port'),
11428            port_override=d.get('port_override'),
11429            schema=d.get('schema'),
11430            secret_store_id=d.get('secret_store_id'),
11431            tags=d.get('tags'),
11432            username=d.get('username'),
11433        )
class SSH:
11436class SSH:
11437    '''
11438
11439    '''
11440    __slots__ = [
11441        'allow_deprecated_key_exchanges',
11442        'bind_interface',
11443        'egress_filter',
11444        'healthy',
11445        'hostname',
11446        'id',
11447        'key_type',
11448        'name',
11449        'port',
11450        'port_forwarding',
11451        'port_override',
11452        'public_key',
11453        'secret_store_id',
11454        'tags',
11455        'username',
11456    ]
11457
11458    def __init__(
11459        self,
11460        allow_deprecated_key_exchanges=None,
11461        bind_interface=None,
11462        egress_filter=None,
11463        healthy=None,
11464        hostname=None,
11465        id=None,
11466        key_type=None,
11467        name=None,
11468        port=None,
11469        port_forwarding=None,
11470        port_override=None,
11471        public_key=None,
11472        secret_store_id=None,
11473        tags=None,
11474        username=None,
11475    ):
11476        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11477        '''
11478
11479        '''
11480        self.bind_interface = bind_interface if bind_interface is not None else ''
11481        '''
11482         Bind interface
11483        '''
11484        self.egress_filter = egress_filter if egress_filter is not None else ''
11485        '''
11486         A filter applied to the routing logic to pin datasource to nodes.
11487        '''
11488        self.healthy = healthy if healthy is not None else False
11489        '''
11490         True if the datasource is reachable and the credentials are valid.
11491        '''
11492        self.hostname = hostname if hostname is not None else ''
11493        '''
11494
11495        '''
11496        self.id = id if id is not None else ''
11497        '''
11498         Unique identifier of the Resource.
11499        '''
11500        self.key_type = key_type if key_type is not None else ''
11501        '''
11502
11503        '''
11504        self.name = name if name is not None else ''
11505        '''
11506         Unique human-readable name of the Resource.
11507        '''
11508        self.port = port if port is not None else 0
11509        '''
11510
11511        '''
11512        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11513        '''
11514
11515        '''
11516        self.port_override = port_override if port_override is not None else 0
11517        '''
11518
11519        '''
11520        self.public_key = public_key if public_key is not None else ''
11521        '''
11522
11523        '''
11524        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11525        '''
11526         ID of the secret store containing credentials for this resource, if any.
11527        '''
11528        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11529        '''
11530         Tags is a map of key, value pairs.
11531        '''
11532        self.username = username if username is not None else ''
11533        '''
11534
11535        '''
11536
11537    def __repr__(self):
11538        return '<sdm.SSH ' + \
11539            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11540            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11541            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11542            'healthy: ' + repr(self.healthy) + ' ' +\
11543            'hostname: ' + repr(self.hostname) + ' ' +\
11544            'id: ' + repr(self.id) + ' ' +\
11545            'key_type: ' + repr(self.key_type) + ' ' +\
11546            'name: ' + repr(self.name) + ' ' +\
11547            'port: ' + repr(self.port) + ' ' +\
11548            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11549            'port_override: ' + repr(self.port_override) + ' ' +\
11550            'public_key: ' + repr(self.public_key) + ' ' +\
11551            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11552            'tags: ' + repr(self.tags) + ' ' +\
11553            'username: ' + repr(self.username) + ' ' +\
11554            '>'
11555
11556    def to_dict(self):
11557        return {
11558            'allow_deprecated_key_exchanges':
11559            self.allow_deprecated_key_exchanges,
11560            'bind_interface': self.bind_interface,
11561            'egress_filter': self.egress_filter,
11562            'healthy': self.healthy,
11563            'hostname': self.hostname,
11564            'id': self.id,
11565            'key_type': self.key_type,
11566            'name': self.name,
11567            'port': self.port,
11568            'port_forwarding': self.port_forwarding,
11569            'port_override': self.port_override,
11570            'public_key': self.public_key,
11571            'secret_store_id': self.secret_store_id,
11572            'tags': self.tags,
11573            'username': self.username,
11574        }
11575
11576    @classmethod
11577    def from_dict(cls, d):
11578        return cls(
11579            allow_deprecated_key_exchanges=d.get(
11580                'allow_deprecated_key_exchanges'),
11581            bind_interface=d.get('bind_interface'),
11582            egress_filter=d.get('egress_filter'),
11583            healthy=d.get('healthy'),
11584            hostname=d.get('hostname'),
11585            id=d.get('id'),
11586            key_type=d.get('key_type'),
11587            name=d.get('name'),
11588            port=d.get('port'),
11589            port_forwarding=d.get('port_forwarding'),
11590            port_override=d.get('port_override'),
11591            public_key=d.get('public_key'),
11592            secret_store_id=d.get('secret_store_id'),
11593            tags=d.get('tags'),
11594            username=d.get('username'),
11595        )
SSH( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, key_type=None, name=None, port=None, port_forwarding=None, port_override=None, public_key=None, secret_store_id=None, tags=None, username=None)
11458    def __init__(
11459        self,
11460        allow_deprecated_key_exchanges=None,
11461        bind_interface=None,
11462        egress_filter=None,
11463        healthy=None,
11464        hostname=None,
11465        id=None,
11466        key_type=None,
11467        name=None,
11468        port=None,
11469        port_forwarding=None,
11470        port_override=None,
11471        public_key=None,
11472        secret_store_id=None,
11473        tags=None,
11474        username=None,
11475    ):
11476        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11477        '''
11478
11479        '''
11480        self.bind_interface = bind_interface if bind_interface is not None else ''
11481        '''
11482         Bind interface
11483        '''
11484        self.egress_filter = egress_filter if egress_filter is not None else ''
11485        '''
11486         A filter applied to the routing logic to pin datasource to nodes.
11487        '''
11488        self.healthy = healthy if healthy is not None else False
11489        '''
11490         True if the datasource is reachable and the credentials are valid.
11491        '''
11492        self.hostname = hostname if hostname is not None else ''
11493        '''
11494
11495        '''
11496        self.id = id if id is not None else ''
11497        '''
11498         Unique identifier of the Resource.
11499        '''
11500        self.key_type = key_type if key_type is not None else ''
11501        '''
11502
11503        '''
11504        self.name = name if name is not None else ''
11505        '''
11506         Unique human-readable name of the Resource.
11507        '''
11508        self.port = port if port is not None else 0
11509        '''
11510
11511        '''
11512        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11513        '''
11514
11515        '''
11516        self.port_override = port_override if port_override is not None else 0
11517        '''
11518
11519        '''
11520        self.public_key = public_key if public_key is not None else ''
11521        '''
11522
11523        '''
11524        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11525        '''
11526         ID of the secret store containing credentials for this resource, if any.
11527        '''
11528        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11529        '''
11530         Tags is a map of key, value pairs.
11531        '''
11532        self.username = username if username is not None else ''
11533        '''
11534
11535        '''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

key_type
name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
public_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11556    def to_dict(self):
11557        return {
11558            'allow_deprecated_key_exchanges':
11559            self.allow_deprecated_key_exchanges,
11560            'bind_interface': self.bind_interface,
11561            'egress_filter': self.egress_filter,
11562            'healthy': self.healthy,
11563            'hostname': self.hostname,
11564            'id': self.id,
11565            'key_type': self.key_type,
11566            'name': self.name,
11567            'port': self.port,
11568            'port_forwarding': self.port_forwarding,
11569            'port_override': self.port_override,
11570            'public_key': self.public_key,
11571            'secret_store_id': self.secret_store_id,
11572            'tags': self.tags,
11573            'username': self.username,
11574        }
@classmethod
def from_dict(cls, d)
11576    @classmethod
11577    def from_dict(cls, d):
11578        return cls(
11579            allow_deprecated_key_exchanges=d.get(
11580                'allow_deprecated_key_exchanges'),
11581            bind_interface=d.get('bind_interface'),
11582            egress_filter=d.get('egress_filter'),
11583            healthy=d.get('healthy'),
11584            hostname=d.get('hostname'),
11585            id=d.get('id'),
11586            key_type=d.get('key_type'),
11587            name=d.get('name'),
11588            port=d.get('port'),
11589            port_forwarding=d.get('port_forwarding'),
11590            port_override=d.get('port_override'),
11591            public_key=d.get('public_key'),
11592            secret_store_id=d.get('secret_store_id'),
11593            tags=d.get('tags'),
11594            username=d.get('username'),
11595        )
class SSHCert:
11598class SSHCert:
11599    '''
11600
11601    '''
11602    __slots__ = [
11603        'allow_deprecated_key_exchanges',
11604        'bind_interface',
11605        'egress_filter',
11606        'healthy',
11607        'hostname',
11608        'id',
11609        'key_type',
11610        'name',
11611        'port',
11612        'port_forwarding',
11613        'port_override',
11614        'remote_identity_group_id',
11615        'remote_identity_healthcheck_username',
11616        'secret_store_id',
11617        'tags',
11618        'username',
11619    ]
11620
11621    def __init__(
11622        self,
11623        allow_deprecated_key_exchanges=None,
11624        bind_interface=None,
11625        egress_filter=None,
11626        healthy=None,
11627        hostname=None,
11628        id=None,
11629        key_type=None,
11630        name=None,
11631        port=None,
11632        port_forwarding=None,
11633        port_override=None,
11634        remote_identity_group_id=None,
11635        remote_identity_healthcheck_username=None,
11636        secret_store_id=None,
11637        tags=None,
11638        username=None,
11639    ):
11640        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11641        '''
11642
11643        '''
11644        self.bind_interface = bind_interface if bind_interface is not None else ''
11645        '''
11646         Bind interface
11647        '''
11648        self.egress_filter = egress_filter if egress_filter is not None else ''
11649        '''
11650         A filter applied to the routing logic to pin datasource to nodes.
11651        '''
11652        self.healthy = healthy if healthy is not None else False
11653        '''
11654         True if the datasource is reachable and the credentials are valid.
11655        '''
11656        self.hostname = hostname if hostname is not None else ''
11657        '''
11658
11659        '''
11660        self.id = id if id is not None else ''
11661        '''
11662         Unique identifier of the Resource.
11663        '''
11664        self.key_type = key_type if key_type is not None else ''
11665        '''
11666
11667        '''
11668        self.name = name if name is not None else ''
11669        '''
11670         Unique human-readable name of the Resource.
11671        '''
11672        self.port = port if port is not None else 0
11673        '''
11674
11675        '''
11676        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11677        '''
11678
11679        '''
11680        self.port_override = port_override if port_override is not None else 0
11681        '''
11682
11683        '''
11684        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
11685        '''
11686
11687        '''
11688        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
11689        '''
11690
11691        '''
11692        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11693        '''
11694         ID of the secret store containing credentials for this resource, if any.
11695        '''
11696        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11697        '''
11698         Tags is a map of key, value pairs.
11699        '''
11700        self.username = username if username is not None else ''
11701        '''
11702
11703        '''
11704
11705    def __repr__(self):
11706        return '<sdm.SSHCert ' + \
11707            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11708            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11709            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11710            'healthy: ' + repr(self.healthy) + ' ' +\
11711            'hostname: ' + repr(self.hostname) + ' ' +\
11712            'id: ' + repr(self.id) + ' ' +\
11713            'key_type: ' + repr(self.key_type) + ' ' +\
11714            'name: ' + repr(self.name) + ' ' +\
11715            'port: ' + repr(self.port) + ' ' +\
11716            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11717            'port_override: ' + repr(self.port_override) + ' ' +\
11718            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
11719            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
11720            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11721            'tags: ' + repr(self.tags) + ' ' +\
11722            'username: ' + repr(self.username) + ' ' +\
11723            '>'
11724
11725    def to_dict(self):
11726        return {
11727            'allow_deprecated_key_exchanges':
11728            self.allow_deprecated_key_exchanges,
11729            'bind_interface': self.bind_interface,
11730            'egress_filter': self.egress_filter,
11731            'healthy': self.healthy,
11732            'hostname': self.hostname,
11733            'id': self.id,
11734            'key_type': self.key_type,
11735            'name': self.name,
11736            'port': self.port,
11737            'port_forwarding': self.port_forwarding,
11738            'port_override': self.port_override,
11739            'remote_identity_group_id': self.remote_identity_group_id,
11740            'remote_identity_healthcheck_username':
11741            self.remote_identity_healthcheck_username,
11742            'secret_store_id': self.secret_store_id,
11743            'tags': self.tags,
11744            'username': self.username,
11745        }
11746
11747    @classmethod
11748    def from_dict(cls, d):
11749        return cls(
11750            allow_deprecated_key_exchanges=d.get(
11751                'allow_deprecated_key_exchanges'),
11752            bind_interface=d.get('bind_interface'),
11753            egress_filter=d.get('egress_filter'),
11754            healthy=d.get('healthy'),
11755            hostname=d.get('hostname'),
11756            id=d.get('id'),
11757            key_type=d.get('key_type'),
11758            name=d.get('name'),
11759            port=d.get('port'),
11760            port_forwarding=d.get('port_forwarding'),
11761            port_override=d.get('port_override'),
11762            remote_identity_group_id=d.get('remote_identity_group_id'),
11763            remote_identity_healthcheck_username=d.get(
11764                'remote_identity_healthcheck_username'),
11765            secret_store_id=d.get('secret_store_id'),
11766            tags=d.get('tags'),
11767            username=d.get('username'),
11768        )
SSHCert( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, key_type=None, name=None, port=None, port_forwarding=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, username=None)
11621    def __init__(
11622        self,
11623        allow_deprecated_key_exchanges=None,
11624        bind_interface=None,
11625        egress_filter=None,
11626        healthy=None,
11627        hostname=None,
11628        id=None,
11629        key_type=None,
11630        name=None,
11631        port=None,
11632        port_forwarding=None,
11633        port_override=None,
11634        remote_identity_group_id=None,
11635        remote_identity_healthcheck_username=None,
11636        secret_store_id=None,
11637        tags=None,
11638        username=None,
11639    ):
11640        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11641        '''
11642
11643        '''
11644        self.bind_interface = bind_interface if bind_interface is not None else ''
11645        '''
11646         Bind interface
11647        '''
11648        self.egress_filter = egress_filter if egress_filter is not None else ''
11649        '''
11650         A filter applied to the routing logic to pin datasource to nodes.
11651        '''
11652        self.healthy = healthy if healthy is not None else False
11653        '''
11654         True if the datasource is reachable and the credentials are valid.
11655        '''
11656        self.hostname = hostname if hostname is not None else ''
11657        '''
11658
11659        '''
11660        self.id = id if id is not None else ''
11661        '''
11662         Unique identifier of the Resource.
11663        '''
11664        self.key_type = key_type if key_type is not None else ''
11665        '''
11666
11667        '''
11668        self.name = name if name is not None else ''
11669        '''
11670         Unique human-readable name of the Resource.
11671        '''
11672        self.port = port if port is not None else 0
11673        '''
11674
11675        '''
11676        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11677        '''
11678
11679        '''
11680        self.port_override = port_override if port_override is not None else 0
11681        '''
11682
11683        '''
11684        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
11685        '''
11686
11687        '''
11688        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
11689        '''
11690
11691        '''
11692        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11693        '''
11694         ID of the secret store containing credentials for this resource, if any.
11695        '''
11696        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11697        '''
11698         Tags is a map of key, value pairs.
11699        '''
11700        self.username = username if username is not None else ''
11701        '''
11702
11703        '''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

key_type
name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11725    def to_dict(self):
11726        return {
11727            'allow_deprecated_key_exchanges':
11728            self.allow_deprecated_key_exchanges,
11729            'bind_interface': self.bind_interface,
11730            'egress_filter': self.egress_filter,
11731            'healthy': self.healthy,
11732            'hostname': self.hostname,
11733            'id': self.id,
11734            'key_type': self.key_type,
11735            'name': self.name,
11736            'port': self.port,
11737            'port_forwarding': self.port_forwarding,
11738            'port_override': self.port_override,
11739            'remote_identity_group_id': self.remote_identity_group_id,
11740            'remote_identity_healthcheck_username':
11741            self.remote_identity_healthcheck_username,
11742            'secret_store_id': self.secret_store_id,
11743            'tags': self.tags,
11744            'username': self.username,
11745        }
@classmethod
def from_dict(cls, d)
11747    @classmethod
11748    def from_dict(cls, d):
11749        return cls(
11750            allow_deprecated_key_exchanges=d.get(
11751                'allow_deprecated_key_exchanges'),
11752            bind_interface=d.get('bind_interface'),
11753            egress_filter=d.get('egress_filter'),
11754            healthy=d.get('healthy'),
11755            hostname=d.get('hostname'),
11756            id=d.get('id'),
11757            key_type=d.get('key_type'),
11758            name=d.get('name'),
11759            port=d.get('port'),
11760            port_forwarding=d.get('port_forwarding'),
11761            port_override=d.get('port_override'),
11762            remote_identity_group_id=d.get('remote_identity_group_id'),
11763            remote_identity_healthcheck_username=d.get(
11764                'remote_identity_healthcheck_username'),
11765            secret_store_id=d.get('secret_store_id'),
11766            tags=d.get('tags'),
11767            username=d.get('username'),
11768        )
class SSHCustomerKey:
11771class SSHCustomerKey:
11772    '''
11773
11774    '''
11775    __slots__ = [
11776        'allow_deprecated_key_exchanges',
11777        'bind_interface',
11778        'egress_filter',
11779        'healthy',
11780        'hostname',
11781        'id',
11782        'name',
11783        'port',
11784        'port_forwarding',
11785        'port_override',
11786        'private_key',
11787        'secret_store_id',
11788        'tags',
11789        'username',
11790    ]
11791
11792    def __init__(
11793        self,
11794        allow_deprecated_key_exchanges=None,
11795        bind_interface=None,
11796        egress_filter=None,
11797        healthy=None,
11798        hostname=None,
11799        id=None,
11800        name=None,
11801        port=None,
11802        port_forwarding=None,
11803        port_override=None,
11804        private_key=None,
11805        secret_store_id=None,
11806        tags=None,
11807        username=None,
11808    ):
11809        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11810        '''
11811
11812        '''
11813        self.bind_interface = bind_interface if bind_interface is not None else ''
11814        '''
11815         Bind interface
11816        '''
11817        self.egress_filter = egress_filter if egress_filter is not None else ''
11818        '''
11819         A filter applied to the routing logic to pin datasource to nodes.
11820        '''
11821        self.healthy = healthy if healthy is not None else False
11822        '''
11823         True if the datasource is reachable and the credentials are valid.
11824        '''
11825        self.hostname = hostname if hostname is not None else ''
11826        '''
11827
11828        '''
11829        self.id = id if id is not None else ''
11830        '''
11831         Unique identifier of the Resource.
11832        '''
11833        self.name = name if name is not None else ''
11834        '''
11835         Unique human-readable name of the Resource.
11836        '''
11837        self.port = port if port is not None else 0
11838        '''
11839
11840        '''
11841        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11842        '''
11843
11844        '''
11845        self.port_override = port_override if port_override is not None else 0
11846        '''
11847
11848        '''
11849        self.private_key = private_key if private_key is not None else ''
11850        '''
11851
11852        '''
11853        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11854        '''
11855         ID of the secret store containing credentials for this resource, if any.
11856        '''
11857        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11858        '''
11859         Tags is a map of key, value pairs.
11860        '''
11861        self.username = username if username is not None else ''
11862        '''
11863
11864        '''
11865
11866    def __repr__(self):
11867        return '<sdm.SSHCustomerKey ' + \
11868            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11869            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11870            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11871            'healthy: ' + repr(self.healthy) + ' ' +\
11872            'hostname: ' + repr(self.hostname) + ' ' +\
11873            'id: ' + repr(self.id) + ' ' +\
11874            'name: ' + repr(self.name) + ' ' +\
11875            'port: ' + repr(self.port) + ' ' +\
11876            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11877            'port_override: ' + repr(self.port_override) + ' ' +\
11878            'private_key: ' + repr(self.private_key) + ' ' +\
11879            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11880            'tags: ' + repr(self.tags) + ' ' +\
11881            'username: ' + repr(self.username) + ' ' +\
11882            '>'
11883
11884    def to_dict(self):
11885        return {
11886            'allow_deprecated_key_exchanges':
11887            self.allow_deprecated_key_exchanges,
11888            'bind_interface': self.bind_interface,
11889            'egress_filter': self.egress_filter,
11890            'healthy': self.healthy,
11891            'hostname': self.hostname,
11892            'id': self.id,
11893            'name': self.name,
11894            'port': self.port,
11895            'port_forwarding': self.port_forwarding,
11896            'port_override': self.port_override,
11897            'private_key': self.private_key,
11898            'secret_store_id': self.secret_store_id,
11899            'tags': self.tags,
11900            'username': self.username,
11901        }
11902
11903    @classmethod
11904    def from_dict(cls, d):
11905        return cls(
11906            allow_deprecated_key_exchanges=d.get(
11907                'allow_deprecated_key_exchanges'),
11908            bind_interface=d.get('bind_interface'),
11909            egress_filter=d.get('egress_filter'),
11910            healthy=d.get('healthy'),
11911            hostname=d.get('hostname'),
11912            id=d.get('id'),
11913            name=d.get('name'),
11914            port=d.get('port'),
11915            port_forwarding=d.get('port_forwarding'),
11916            port_override=d.get('port_override'),
11917            private_key=d.get('private_key'),
11918            secret_store_id=d.get('secret_store_id'),
11919            tags=d.get('tags'),
11920            username=d.get('username'),
11921        )
SSHCustomerKey( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_forwarding=None, port_override=None, private_key=None, secret_store_id=None, tags=None, username=None)
11792    def __init__(
11793        self,
11794        allow_deprecated_key_exchanges=None,
11795        bind_interface=None,
11796        egress_filter=None,
11797        healthy=None,
11798        hostname=None,
11799        id=None,
11800        name=None,
11801        port=None,
11802        port_forwarding=None,
11803        port_override=None,
11804        private_key=None,
11805        secret_store_id=None,
11806        tags=None,
11807        username=None,
11808    ):
11809        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11810        '''
11811
11812        '''
11813        self.bind_interface = bind_interface if bind_interface is not None else ''
11814        '''
11815         Bind interface
11816        '''
11817        self.egress_filter = egress_filter if egress_filter is not None else ''
11818        '''
11819         A filter applied to the routing logic to pin datasource to nodes.
11820        '''
11821        self.healthy = healthy if healthy is not None else False
11822        '''
11823         True if the datasource is reachable and the credentials are valid.
11824        '''
11825        self.hostname = hostname if hostname is not None else ''
11826        '''
11827
11828        '''
11829        self.id = id if id is not None else ''
11830        '''
11831         Unique identifier of the Resource.
11832        '''
11833        self.name = name if name is not None else ''
11834        '''
11835         Unique human-readable name of the Resource.
11836        '''
11837        self.port = port if port is not None else 0
11838        '''
11839
11840        '''
11841        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11842        '''
11843
11844        '''
11845        self.port_override = port_override if port_override is not None else 0
11846        '''
11847
11848        '''
11849        self.private_key = private_key if private_key is not None else ''
11850        '''
11851
11852        '''
11853        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11854        '''
11855         ID of the secret store containing credentials for this resource, if any.
11856        '''
11857        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11858        '''
11859         Tags is a map of key, value pairs.
11860        '''
11861        self.username = username if username is not None else ''
11862        '''
11863
11864        '''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
private_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11884    def to_dict(self):
11885        return {
11886            'allow_deprecated_key_exchanges':
11887            self.allow_deprecated_key_exchanges,
11888            'bind_interface': self.bind_interface,
11889            'egress_filter': self.egress_filter,
11890            'healthy': self.healthy,
11891            'hostname': self.hostname,
11892            'id': self.id,
11893            'name': self.name,
11894            'port': self.port,
11895            'port_forwarding': self.port_forwarding,
11896            'port_override': self.port_override,
11897            'private_key': self.private_key,
11898            'secret_store_id': self.secret_store_id,
11899            'tags': self.tags,
11900            'username': self.username,
11901        }
@classmethod
def from_dict(cls, d)
11903    @classmethod
11904    def from_dict(cls, d):
11905        return cls(
11906            allow_deprecated_key_exchanges=d.get(
11907                'allow_deprecated_key_exchanges'),
11908            bind_interface=d.get('bind_interface'),
11909            egress_filter=d.get('egress_filter'),
11910            healthy=d.get('healthy'),
11911            hostname=d.get('hostname'),
11912            id=d.get('id'),
11913            name=d.get('name'),
11914            port=d.get('port'),
11915            port_forwarding=d.get('port_forwarding'),
11916            port_override=d.get('port_override'),
11917            private_key=d.get('private_key'),
11918            secret_store_id=d.get('secret_store_id'),
11919            tags=d.get('tags'),
11920            username=d.get('username'),
11921        )
class SecretStoreCreateResponse:
11924class SecretStoreCreateResponse:
11925    '''
11926     SecretStoreCreateResponse reports how the SecretStores were created in the system.
11927    '''
11928    __slots__ = [
11929        'meta',
11930        'rate_limit',
11931        'secret_store',
11932    ]
11933
11934    def __init__(
11935        self,
11936        meta=None,
11937        rate_limit=None,
11938        secret_store=None,
11939    ):
11940        self.meta = meta if meta is not None else None
11941        '''
11942         Reserved for future use.
11943        '''
11944        self.rate_limit = rate_limit if rate_limit is not None else None
11945        '''
11946         Rate limit information.
11947        '''
11948        self.secret_store = secret_store if secret_store is not None else None
11949        '''
11950         The created SecretStore.
11951        '''
11952
11953    def __repr__(self):
11954        return '<sdm.SecretStoreCreateResponse ' + \
11955            'meta: ' + repr(self.meta) + ' ' +\
11956            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11957            'secret_store: ' + repr(self.secret_store) + ' ' +\
11958            '>'
11959
11960    def to_dict(self):
11961        return {
11962            'meta': self.meta,
11963            'rate_limit': self.rate_limit,
11964            'secret_store': self.secret_store,
11965        }
11966
11967    @classmethod
11968    def from_dict(cls, d):
11969        return cls(
11970            meta=d.get('meta'),
11971            rate_limit=d.get('rate_limit'),
11972            secret_store=d.get('secret_store'),
11973        )

SecretStoreCreateResponse reports how the SecretStores were created in the system.

SecretStoreCreateResponse(meta=None, rate_limit=None, secret_store=None)
11934    def __init__(
11935        self,
11936        meta=None,
11937        rate_limit=None,
11938        secret_store=None,
11939    ):
11940        self.meta = meta if meta is not None else None
11941        '''
11942         Reserved for future use.
11943        '''
11944        self.rate_limit = rate_limit if rate_limit is not None else None
11945        '''
11946         Rate limit information.
11947        '''
11948        self.secret_store = secret_store if secret_store is not None else None
11949        '''
11950         The created SecretStore.
11951        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The created SecretStore.

def to_dict(self)
11960    def to_dict(self):
11961        return {
11962            'meta': self.meta,
11963            'rate_limit': self.rate_limit,
11964            'secret_store': self.secret_store,
11965        }
@classmethod
def from_dict(cls, d)
11967    @classmethod
11968    def from_dict(cls, d):
11969        return cls(
11970            meta=d.get('meta'),
11971            rate_limit=d.get('rate_limit'),
11972            secret_store=d.get('secret_store'),
11973        )
class SecretStoreDeleteResponse:
11976class SecretStoreDeleteResponse:
11977    '''
11978     SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
11979    '''
11980    __slots__ = [
11981        'meta',
11982        'rate_limit',
11983    ]
11984
11985    def __init__(
11986        self,
11987        meta=None,
11988        rate_limit=None,
11989    ):
11990        self.meta = meta if meta is not None else None
11991        '''
11992         Reserved for future use.
11993        '''
11994        self.rate_limit = rate_limit if rate_limit is not None else None
11995        '''
11996         Rate limit information.
11997        '''
11998
11999    def __repr__(self):
12000        return '<sdm.SecretStoreDeleteResponse ' + \
12001            'meta: ' + repr(self.meta) + ' ' +\
12002            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12003            '>'
12004
12005    def to_dict(self):
12006        return {
12007            'meta': self.meta,
12008            'rate_limit': self.rate_limit,
12009        }
12010
12011    @classmethod
12012    def from_dict(cls, d):
12013        return cls(
12014            meta=d.get('meta'),
12015            rate_limit=d.get('rate_limit'),
12016        )

SecretStoreDeleteResponse returns information about a SecretStore that was deleted.

SecretStoreDeleteResponse(meta=None, rate_limit=None)
11985    def __init__(
11986        self,
11987        meta=None,
11988        rate_limit=None,
11989    ):
11990        self.meta = meta if meta is not None else None
11991        '''
11992         Reserved for future use.
11993        '''
11994        self.rate_limit = rate_limit if rate_limit is not None else None
11995        '''
11996         Rate limit information.
11997        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
12005    def to_dict(self):
12006        return {
12007            'meta': self.meta,
12008            'rate_limit': self.rate_limit,
12009        }
@classmethod
def from_dict(cls, d)
12011    @classmethod
12012    def from_dict(cls, d):
12013        return cls(
12014            meta=d.get('meta'),
12015            rate_limit=d.get('rate_limit'),
12016        )
class SecretStoreGetResponse:
12019class SecretStoreGetResponse:
12020    '''
12021     SecretStoreGetResponse returns a requested SecretStore.
12022    '''
12023    __slots__ = [
12024        'meta',
12025        'rate_limit',
12026        'secret_store',
12027    ]
12028
12029    def __init__(
12030        self,
12031        meta=None,
12032        rate_limit=None,
12033        secret_store=None,
12034    ):
12035        self.meta = meta if meta is not None else None
12036        '''
12037         Reserved for future use.
12038        '''
12039        self.rate_limit = rate_limit if rate_limit is not None else None
12040        '''
12041         Rate limit information.
12042        '''
12043        self.secret_store = secret_store if secret_store is not None else None
12044        '''
12045         The requested SecretStore.
12046        '''
12047
12048    def __repr__(self):
12049        return '<sdm.SecretStoreGetResponse ' + \
12050            'meta: ' + repr(self.meta) + ' ' +\
12051            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12052            'secret_store: ' + repr(self.secret_store) + ' ' +\
12053            '>'
12054
12055    def to_dict(self):
12056        return {
12057            'meta': self.meta,
12058            'rate_limit': self.rate_limit,
12059            'secret_store': self.secret_store,
12060        }
12061
12062    @classmethod
12063    def from_dict(cls, d):
12064        return cls(
12065            meta=d.get('meta'),
12066            rate_limit=d.get('rate_limit'),
12067            secret_store=d.get('secret_store'),
12068        )

SecretStoreGetResponse returns a requested SecretStore.

SecretStoreGetResponse(meta=None, rate_limit=None, secret_store=None)
12029    def __init__(
12030        self,
12031        meta=None,
12032        rate_limit=None,
12033        secret_store=None,
12034    ):
12035        self.meta = meta if meta is not None else None
12036        '''
12037         Reserved for future use.
12038        '''
12039        self.rate_limit = rate_limit if rate_limit is not None else None
12040        '''
12041         Rate limit information.
12042        '''
12043        self.secret_store = secret_store if secret_store is not None else None
12044        '''
12045         The requested SecretStore.
12046        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The requested SecretStore.

def to_dict(self)
12055    def to_dict(self):
12056        return {
12057            'meta': self.meta,
12058            'rate_limit': self.rate_limit,
12059            'secret_store': self.secret_store,
12060        }
@classmethod
def from_dict(cls, d)
12062    @classmethod
12063    def from_dict(cls, d):
12064        return cls(
12065            meta=d.get('meta'),
12066            rate_limit=d.get('rate_limit'),
12067            secret_store=d.get('secret_store'),
12068        )
class SecretStoreUpdateResponse:
12071class SecretStoreUpdateResponse:
12072    '''
12073     SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
12074     a SecretStoreUpdateRequest.
12075    '''
12076    __slots__ = [
12077        'meta',
12078        'rate_limit',
12079        'secret_store',
12080    ]
12081
12082    def __init__(
12083        self,
12084        meta=None,
12085        rate_limit=None,
12086        secret_store=None,
12087    ):
12088        self.meta = meta if meta is not None else None
12089        '''
12090         Reserved for future use.
12091        '''
12092        self.rate_limit = rate_limit if rate_limit is not None else None
12093        '''
12094         Rate limit information.
12095        '''
12096        self.secret_store = secret_store if secret_store is not None else None
12097        '''
12098         The updated SecretStore.
12099        '''
12100
12101    def __repr__(self):
12102        return '<sdm.SecretStoreUpdateResponse ' + \
12103            'meta: ' + repr(self.meta) + ' ' +\
12104            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12105            'secret_store: ' + repr(self.secret_store) + ' ' +\
12106            '>'
12107
12108    def to_dict(self):
12109        return {
12110            'meta': self.meta,
12111            'rate_limit': self.rate_limit,
12112            'secret_store': self.secret_store,
12113        }
12114
12115    @classmethod
12116    def from_dict(cls, d):
12117        return cls(
12118            meta=d.get('meta'),
12119            rate_limit=d.get('rate_limit'),
12120            secret_store=d.get('secret_store'),
12121        )

SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by a SecretStoreUpdateRequest.

SecretStoreUpdateResponse(meta=None, rate_limit=None, secret_store=None)
12082    def __init__(
12083        self,
12084        meta=None,
12085        rate_limit=None,
12086        secret_store=None,
12087    ):
12088        self.meta = meta if meta is not None else None
12089        '''
12090         Reserved for future use.
12091        '''
12092        self.rate_limit = rate_limit if rate_limit is not None else None
12093        '''
12094         Rate limit information.
12095        '''
12096        self.secret_store = secret_store if secret_store is not None else None
12097        '''
12098         The updated SecretStore.
12099        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The updated SecretStore.

def to_dict(self)
12108    def to_dict(self):
12109        return {
12110            'meta': self.meta,
12111            'rate_limit': self.rate_limit,
12112            'secret_store': self.secret_store,
12113        }
@classmethod
def from_dict(cls, d)
12115    @classmethod
12116    def from_dict(cls, d):
12117        return cls(
12118            meta=d.get('meta'),
12119            rate_limit=d.get('rate_limit'),
12120            secret_store=d.get('secret_store'),
12121        )
class Service:
12124class Service:
12125    '''
12126     A Service is a service account that can connect to resources they are granted
12127     directly, or granted via roles. Services are typically automated jobs.
12128    '''
12129    __slots__ = [
12130        'id',
12131        'name',
12132        'suspended',
12133        'tags',
12134    ]
12135
12136    def __init__(
12137        self,
12138        id=None,
12139        name=None,
12140        suspended=None,
12141        tags=None,
12142    ):
12143        self.id = id if id is not None else ''
12144        '''
12145         Unique identifier of the Service.
12146        '''
12147        self.name = name if name is not None else ''
12148        '''
12149         Unique human-readable name of the Service.
12150        '''
12151        self.suspended = suspended if suspended is not None else False
12152        '''
12153         The Service's suspended state.
12154        '''
12155        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12156        '''
12157         Tags is a map of key, value pairs.
12158        '''
12159
12160    def __repr__(self):
12161        return '<sdm.Service ' + \
12162            'id: ' + repr(self.id) + ' ' +\
12163            'name: ' + repr(self.name) + ' ' +\
12164            'suspended: ' + repr(self.suspended) + ' ' +\
12165            'tags: ' + repr(self.tags) + ' ' +\
12166            '>'
12167
12168    def to_dict(self):
12169        return {
12170            'id': self.id,
12171            'name': self.name,
12172            'suspended': self.suspended,
12173            'tags': self.tags,
12174        }
12175
12176    @classmethod
12177    def from_dict(cls, d):
12178        return cls(
12179            id=d.get('id'),
12180            name=d.get('name'),
12181            suspended=d.get('suspended'),
12182            tags=d.get('tags'),
12183        )

A Service is a service account that can connect to resources they are granted directly, or granted via roles. Services are typically automated jobs.

Service(id=None, name=None, suspended=None, tags=None)
12136    def __init__(
12137        self,
12138        id=None,
12139        name=None,
12140        suspended=None,
12141        tags=None,
12142    ):
12143        self.id = id if id is not None else ''
12144        '''
12145         Unique identifier of the Service.
12146        '''
12147        self.name = name if name is not None else ''
12148        '''
12149         Unique human-readable name of the Service.
12150        '''
12151        self.suspended = suspended if suspended is not None else False
12152        '''
12153         The Service's suspended state.
12154        '''
12155        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12156        '''
12157         Tags is a map of key, value pairs.
12158        '''
id

Unique identifier of the Service.

name

Unique human-readable name of the Service.

suspended

The Service's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
12168    def to_dict(self):
12169        return {
12170            'id': self.id,
12171            'name': self.name,
12172            'suspended': self.suspended,
12173            'tags': self.tags,
12174        }
@classmethod
def from_dict(cls, d)
12176    @classmethod
12177    def from_dict(cls, d):
12178        return cls(
12179            id=d.get('id'),
12180            name=d.get('name'),
12181            suspended=d.get('suspended'),
12182            tags=d.get('tags'),
12183        )
class SingleStore:
12186class SingleStore:
12187    '''
12188
12189    '''
12190    __slots__ = [
12191        'bind_interface',
12192        'database',
12193        'egress_filter',
12194        'healthy',
12195        'hostname',
12196        'id',
12197        'name',
12198        'password',
12199        'port',
12200        'port_override',
12201        'secret_store_id',
12202        'tags',
12203        'username',
12204    ]
12205
12206    def __init__(
12207        self,
12208        bind_interface=None,
12209        database=None,
12210        egress_filter=None,
12211        healthy=None,
12212        hostname=None,
12213        id=None,
12214        name=None,
12215        password=None,
12216        port=None,
12217        port_override=None,
12218        secret_store_id=None,
12219        tags=None,
12220        username=None,
12221    ):
12222        self.bind_interface = bind_interface if bind_interface is not None else ''
12223        '''
12224         Bind interface
12225        '''
12226        self.database = database if database is not None else ''
12227        '''
12228
12229        '''
12230        self.egress_filter = egress_filter if egress_filter is not None else ''
12231        '''
12232         A filter applied to the routing logic to pin datasource to nodes.
12233        '''
12234        self.healthy = healthy if healthy is not None else False
12235        '''
12236         True if the datasource is reachable and the credentials are valid.
12237        '''
12238        self.hostname = hostname if hostname is not None else ''
12239        '''
12240
12241        '''
12242        self.id = id if id is not None else ''
12243        '''
12244         Unique identifier of the Resource.
12245        '''
12246        self.name = name if name is not None else ''
12247        '''
12248         Unique human-readable name of the Resource.
12249        '''
12250        self.password = password if password is not None else ''
12251        '''
12252
12253        '''
12254        self.port = port if port is not None else 0
12255        '''
12256
12257        '''
12258        self.port_override = port_override if port_override is not None else 0
12259        '''
12260
12261        '''
12262        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12263        '''
12264         ID of the secret store containing credentials for this resource, if any.
12265        '''
12266        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12267        '''
12268         Tags is a map of key, value pairs.
12269        '''
12270        self.username = username if username is not None else ''
12271        '''
12272
12273        '''
12274
12275    def __repr__(self):
12276        return '<sdm.SingleStore ' + \
12277            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12278            'database: ' + repr(self.database) + ' ' +\
12279            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12280            'healthy: ' + repr(self.healthy) + ' ' +\
12281            'hostname: ' + repr(self.hostname) + ' ' +\
12282            'id: ' + repr(self.id) + ' ' +\
12283            'name: ' + repr(self.name) + ' ' +\
12284            'password: ' + repr(self.password) + ' ' +\
12285            'port: ' + repr(self.port) + ' ' +\
12286            'port_override: ' + repr(self.port_override) + ' ' +\
12287            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12288            'tags: ' + repr(self.tags) + ' ' +\
12289            'username: ' + repr(self.username) + ' ' +\
12290            '>'
12291
12292    def to_dict(self):
12293        return {
12294            'bind_interface': self.bind_interface,
12295            'database': self.database,
12296            'egress_filter': self.egress_filter,
12297            'healthy': self.healthy,
12298            'hostname': self.hostname,
12299            'id': self.id,
12300            'name': self.name,
12301            'password': self.password,
12302            'port': self.port,
12303            'port_override': self.port_override,
12304            'secret_store_id': self.secret_store_id,
12305            'tags': self.tags,
12306            'username': self.username,
12307        }
12308
12309    @classmethod
12310    def from_dict(cls, d):
12311        return cls(
12312            bind_interface=d.get('bind_interface'),
12313            database=d.get('database'),
12314            egress_filter=d.get('egress_filter'),
12315            healthy=d.get('healthy'),
12316            hostname=d.get('hostname'),
12317            id=d.get('id'),
12318            name=d.get('name'),
12319            password=d.get('password'),
12320            port=d.get('port'),
12321            port_override=d.get('port_override'),
12322            secret_store_id=d.get('secret_store_id'),
12323            tags=d.get('tags'),
12324            username=d.get('username'),
12325        )
SingleStore( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
12206    def __init__(
12207        self,
12208        bind_interface=None,
12209        database=None,
12210        egress_filter=None,
12211        healthy=None,
12212        hostname=None,
12213        id=None,
12214        name=None,
12215        password=None,
12216        port=None,
12217        port_override=None,
12218        secret_store_id=None,
12219        tags=None,
12220        username=None,
12221    ):
12222        self.bind_interface = bind_interface if bind_interface is not None else ''
12223        '''
12224         Bind interface
12225        '''
12226        self.database = database if database is not None else ''
12227        '''
12228
12229        '''
12230        self.egress_filter = egress_filter if egress_filter is not None else ''
12231        '''
12232         A filter applied to the routing logic to pin datasource to nodes.
12233        '''
12234        self.healthy = healthy if healthy is not None else False
12235        '''
12236         True if the datasource is reachable and the credentials are valid.
12237        '''
12238        self.hostname = hostname if hostname is not None else ''
12239        '''
12240
12241        '''
12242        self.id = id if id is not None else ''
12243        '''
12244         Unique identifier of the Resource.
12245        '''
12246        self.name = name if name is not None else ''
12247        '''
12248         Unique human-readable name of the Resource.
12249        '''
12250        self.password = password if password is not None else ''
12251        '''
12252
12253        '''
12254        self.port = port if port is not None else 0
12255        '''
12256
12257        '''
12258        self.port_override = port_override if port_override is not None else 0
12259        '''
12260
12261        '''
12262        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12263        '''
12264         ID of the secret store containing credentials for this resource, if any.
12265        '''
12266        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12267        '''
12268         Tags is a map of key, value pairs.
12269        '''
12270        self.username = username if username is not None else ''
12271        '''
12272
12273        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12292    def to_dict(self):
12293        return {
12294            'bind_interface': self.bind_interface,
12295            'database': self.database,
12296            'egress_filter': self.egress_filter,
12297            'healthy': self.healthy,
12298            'hostname': self.hostname,
12299            'id': self.id,
12300            'name': self.name,
12301            'password': self.password,
12302            'port': self.port,
12303            'port_override': self.port_override,
12304            'secret_store_id': self.secret_store_id,
12305            'tags': self.tags,
12306            'username': self.username,
12307        }
@classmethod
def from_dict(cls, d)
12309    @classmethod
12310    def from_dict(cls, d):
12311        return cls(
12312            bind_interface=d.get('bind_interface'),
12313            database=d.get('database'),
12314            egress_filter=d.get('egress_filter'),
12315            healthy=d.get('healthy'),
12316            hostname=d.get('hostname'),
12317            id=d.get('id'),
12318            name=d.get('name'),
12319            password=d.get('password'),
12320            port=d.get('port'),
12321            port_override=d.get('port_override'),
12322            secret_store_id=d.get('secret_store_id'),
12323            tags=d.get('tags'),
12324            username=d.get('username'),
12325        )
class Snowflake:
12328class Snowflake:
12329    '''
12330
12331    '''
12332    __slots__ = [
12333        'bind_interface',
12334        'database',
12335        'egress_filter',
12336        'healthy',
12337        'hostname',
12338        'id',
12339        'name',
12340        'password',
12341        'port_override',
12342        'schema',
12343        'secret_store_id',
12344        'tags',
12345        'username',
12346    ]
12347
12348    def __init__(
12349        self,
12350        bind_interface=None,
12351        database=None,
12352        egress_filter=None,
12353        healthy=None,
12354        hostname=None,
12355        id=None,
12356        name=None,
12357        password=None,
12358        port_override=None,
12359        schema=None,
12360        secret_store_id=None,
12361        tags=None,
12362        username=None,
12363    ):
12364        self.bind_interface = bind_interface if bind_interface is not None else ''
12365        '''
12366         Bind interface
12367        '''
12368        self.database = database if database is not None else ''
12369        '''
12370
12371        '''
12372        self.egress_filter = egress_filter if egress_filter is not None else ''
12373        '''
12374         A filter applied to the routing logic to pin datasource to nodes.
12375        '''
12376        self.healthy = healthy if healthy is not None else False
12377        '''
12378         True if the datasource is reachable and the credentials are valid.
12379        '''
12380        self.hostname = hostname if hostname is not None else ''
12381        '''
12382
12383        '''
12384        self.id = id if id is not None else ''
12385        '''
12386         Unique identifier of the Resource.
12387        '''
12388        self.name = name if name is not None else ''
12389        '''
12390         Unique human-readable name of the Resource.
12391        '''
12392        self.password = password if password is not None else ''
12393        '''
12394
12395        '''
12396        self.port_override = port_override if port_override is not None else 0
12397        '''
12398
12399        '''
12400        self.schema = schema if schema is not None else ''
12401        '''
12402
12403        '''
12404        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12405        '''
12406         ID of the secret store containing credentials for this resource, if any.
12407        '''
12408        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12409        '''
12410         Tags is a map of key, value pairs.
12411        '''
12412        self.username = username if username is not None else ''
12413        '''
12414
12415        '''
12416
12417    def __repr__(self):
12418        return '<sdm.Snowflake ' + \
12419            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12420            'database: ' + repr(self.database) + ' ' +\
12421            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12422            'healthy: ' + repr(self.healthy) + ' ' +\
12423            'hostname: ' + repr(self.hostname) + ' ' +\
12424            'id: ' + repr(self.id) + ' ' +\
12425            'name: ' + repr(self.name) + ' ' +\
12426            'password: ' + repr(self.password) + ' ' +\
12427            'port_override: ' + repr(self.port_override) + ' ' +\
12428            'schema: ' + repr(self.schema) + ' ' +\
12429            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12430            'tags: ' + repr(self.tags) + ' ' +\
12431            'username: ' + repr(self.username) + ' ' +\
12432            '>'
12433
12434    def to_dict(self):
12435        return {
12436            'bind_interface': self.bind_interface,
12437            'database': self.database,
12438            'egress_filter': self.egress_filter,
12439            'healthy': self.healthy,
12440            'hostname': self.hostname,
12441            'id': self.id,
12442            'name': self.name,
12443            'password': self.password,
12444            'port_override': self.port_override,
12445            'schema': self.schema,
12446            'secret_store_id': self.secret_store_id,
12447            'tags': self.tags,
12448            'username': self.username,
12449        }
12450
12451    @classmethod
12452    def from_dict(cls, d):
12453        return cls(
12454            bind_interface=d.get('bind_interface'),
12455            database=d.get('database'),
12456            egress_filter=d.get('egress_filter'),
12457            healthy=d.get('healthy'),
12458            hostname=d.get('hostname'),
12459            id=d.get('id'),
12460            name=d.get('name'),
12461            password=d.get('password'),
12462            port_override=d.get('port_override'),
12463            schema=d.get('schema'),
12464            secret_store_id=d.get('secret_store_id'),
12465            tags=d.get('tags'),
12466            username=d.get('username'),
12467        )
Snowflake( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
12348    def __init__(
12349        self,
12350        bind_interface=None,
12351        database=None,
12352        egress_filter=None,
12353        healthy=None,
12354        hostname=None,
12355        id=None,
12356        name=None,
12357        password=None,
12358        port_override=None,
12359        schema=None,
12360        secret_store_id=None,
12361        tags=None,
12362        username=None,
12363    ):
12364        self.bind_interface = bind_interface if bind_interface is not None else ''
12365        '''
12366         Bind interface
12367        '''
12368        self.database = database if database is not None else ''
12369        '''
12370
12371        '''
12372        self.egress_filter = egress_filter if egress_filter is not None else ''
12373        '''
12374         A filter applied to the routing logic to pin datasource to nodes.
12375        '''
12376        self.healthy = healthy if healthy is not None else False
12377        '''
12378         True if the datasource is reachable and the credentials are valid.
12379        '''
12380        self.hostname = hostname if hostname is not None else ''
12381        '''
12382
12383        '''
12384        self.id = id if id is not None else ''
12385        '''
12386         Unique identifier of the Resource.
12387        '''
12388        self.name = name if name is not None else ''
12389        '''
12390         Unique human-readable name of the Resource.
12391        '''
12392        self.password = password if password is not None else ''
12393        '''
12394
12395        '''
12396        self.port_override = port_override if port_override is not None else 0
12397        '''
12398
12399        '''
12400        self.schema = schema if schema is not None else ''
12401        '''
12402
12403        '''
12404        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12405        '''
12406         ID of the secret store containing credentials for this resource, if any.
12407        '''
12408        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12409        '''
12410         Tags is a map of key, value pairs.
12411        '''
12412        self.username = username if username is not None else ''
12413        '''
12414
12415        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12434    def to_dict(self):
12435        return {
12436            'bind_interface': self.bind_interface,
12437            'database': self.database,
12438            'egress_filter': self.egress_filter,
12439            'healthy': self.healthy,
12440            'hostname': self.hostname,
12441            'id': self.id,
12442            'name': self.name,
12443            'password': self.password,
12444            'port_override': self.port_override,
12445            'schema': self.schema,
12446            'secret_store_id': self.secret_store_id,
12447            'tags': self.tags,
12448            'username': self.username,
12449        }
@classmethod
def from_dict(cls, d)
12451    @classmethod
12452    def from_dict(cls, d):
12453        return cls(
12454            bind_interface=d.get('bind_interface'),
12455            database=d.get('database'),
12456            egress_filter=d.get('egress_filter'),
12457            healthy=d.get('healthy'),
12458            hostname=d.get('hostname'),
12459            id=d.get('id'),
12460            name=d.get('name'),
12461            password=d.get('password'),
12462            port_override=d.get('port_override'),
12463            schema=d.get('schema'),
12464            secret_store_id=d.get('secret_store_id'),
12465            tags=d.get('tags'),
12466            username=d.get('username'),
12467        )
class Sybase:
12470class Sybase:
12471    '''
12472
12473    '''
12474    __slots__ = [
12475        'bind_interface',
12476        'egress_filter',
12477        'healthy',
12478        'hostname',
12479        'id',
12480        'name',
12481        'password',
12482        'port',
12483        'port_override',
12484        'secret_store_id',
12485        'tags',
12486        'username',
12487    ]
12488
12489    def __init__(
12490        self,
12491        bind_interface=None,
12492        egress_filter=None,
12493        healthy=None,
12494        hostname=None,
12495        id=None,
12496        name=None,
12497        password=None,
12498        port=None,
12499        port_override=None,
12500        secret_store_id=None,
12501        tags=None,
12502        username=None,
12503    ):
12504        self.bind_interface = bind_interface if bind_interface is not None else ''
12505        '''
12506         Bind interface
12507        '''
12508        self.egress_filter = egress_filter if egress_filter is not None else ''
12509        '''
12510         A filter applied to the routing logic to pin datasource to nodes.
12511        '''
12512        self.healthy = healthy if healthy is not None else False
12513        '''
12514         True if the datasource is reachable and the credentials are valid.
12515        '''
12516        self.hostname = hostname if hostname is not None else ''
12517        '''
12518
12519        '''
12520        self.id = id if id is not None else ''
12521        '''
12522         Unique identifier of the Resource.
12523        '''
12524        self.name = name if name is not None else ''
12525        '''
12526         Unique human-readable name of the Resource.
12527        '''
12528        self.password = password if password is not None else ''
12529        '''
12530
12531        '''
12532        self.port = port if port is not None else 0
12533        '''
12534
12535        '''
12536        self.port_override = port_override if port_override is not None else 0
12537        '''
12538
12539        '''
12540        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12541        '''
12542         ID of the secret store containing credentials for this resource, if any.
12543        '''
12544        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12545        '''
12546         Tags is a map of key, value pairs.
12547        '''
12548        self.username = username if username is not None else ''
12549        '''
12550
12551        '''
12552
12553    def __repr__(self):
12554        return '<sdm.Sybase ' + \
12555            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12556            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12557            'healthy: ' + repr(self.healthy) + ' ' +\
12558            'hostname: ' + repr(self.hostname) + ' ' +\
12559            'id: ' + repr(self.id) + ' ' +\
12560            'name: ' + repr(self.name) + ' ' +\
12561            'password: ' + repr(self.password) + ' ' +\
12562            'port: ' + repr(self.port) + ' ' +\
12563            'port_override: ' + repr(self.port_override) + ' ' +\
12564            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12565            'tags: ' + repr(self.tags) + ' ' +\
12566            'username: ' + repr(self.username) + ' ' +\
12567            '>'
12568
12569    def to_dict(self):
12570        return {
12571            'bind_interface': self.bind_interface,
12572            'egress_filter': self.egress_filter,
12573            'healthy': self.healthy,
12574            'hostname': self.hostname,
12575            'id': self.id,
12576            'name': self.name,
12577            'password': self.password,
12578            'port': self.port,
12579            'port_override': self.port_override,
12580            'secret_store_id': self.secret_store_id,
12581            'tags': self.tags,
12582            'username': self.username,
12583        }
12584
12585    @classmethod
12586    def from_dict(cls, d):
12587        return cls(
12588            bind_interface=d.get('bind_interface'),
12589            egress_filter=d.get('egress_filter'),
12590            healthy=d.get('healthy'),
12591            hostname=d.get('hostname'),
12592            id=d.get('id'),
12593            name=d.get('name'),
12594            password=d.get('password'),
12595            port=d.get('port'),
12596            port_override=d.get('port_override'),
12597            secret_store_id=d.get('secret_store_id'),
12598            tags=d.get('tags'),
12599            username=d.get('username'),
12600        )
Sybase( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
12489    def __init__(
12490        self,
12491        bind_interface=None,
12492        egress_filter=None,
12493        healthy=None,
12494        hostname=None,
12495        id=None,
12496        name=None,
12497        password=None,
12498        port=None,
12499        port_override=None,
12500        secret_store_id=None,
12501        tags=None,
12502        username=None,
12503    ):
12504        self.bind_interface = bind_interface if bind_interface is not None else ''
12505        '''
12506         Bind interface
12507        '''
12508        self.egress_filter = egress_filter if egress_filter is not None else ''
12509        '''
12510         A filter applied to the routing logic to pin datasource to nodes.
12511        '''
12512        self.healthy = healthy if healthy is not None else False
12513        '''
12514         True if the datasource is reachable and the credentials are valid.
12515        '''
12516        self.hostname = hostname if hostname is not None else ''
12517        '''
12518
12519        '''
12520        self.id = id if id is not None else ''
12521        '''
12522         Unique identifier of the Resource.
12523        '''
12524        self.name = name if name is not None else ''
12525        '''
12526         Unique human-readable name of the Resource.
12527        '''
12528        self.password = password if password is not None else ''
12529        '''
12530
12531        '''
12532        self.port = port if port is not None else 0
12533        '''
12534
12535        '''
12536        self.port_override = port_override if port_override is not None else 0
12537        '''
12538
12539        '''
12540        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12541        '''
12542         ID of the secret store containing credentials for this resource, if any.
12543        '''
12544        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12545        '''
12546         Tags is a map of key, value pairs.
12547        '''
12548        self.username = username if username is not None else ''
12549        '''
12550
12551        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12569    def to_dict(self):
12570        return {
12571            'bind_interface': self.bind_interface,
12572            'egress_filter': self.egress_filter,
12573            'healthy': self.healthy,
12574            'hostname': self.hostname,
12575            'id': self.id,
12576            'name': self.name,
12577            'password': self.password,
12578            'port': self.port,
12579            'port_override': self.port_override,
12580            'secret_store_id': self.secret_store_id,
12581            'tags': self.tags,
12582            'username': self.username,
12583        }
@classmethod
def from_dict(cls, d)
12585    @classmethod
12586    def from_dict(cls, d):
12587        return cls(
12588            bind_interface=d.get('bind_interface'),
12589            egress_filter=d.get('egress_filter'),
12590            healthy=d.get('healthy'),
12591            hostname=d.get('hostname'),
12592            id=d.get('id'),
12593            name=d.get('name'),
12594            password=d.get('password'),
12595            port=d.get('port'),
12596            port_override=d.get('port_override'),
12597            secret_store_id=d.get('secret_store_id'),
12598            tags=d.get('tags'),
12599            username=d.get('username'),
12600        )
class SybaseIQ:
12603class SybaseIQ:
12604    '''
12605
12606    '''
12607    __slots__ = [
12608        'bind_interface',
12609        'egress_filter',
12610        'healthy',
12611        'hostname',
12612        'id',
12613        'name',
12614        'password',
12615        'port',
12616        'port_override',
12617        'secret_store_id',
12618        'tags',
12619        'username',
12620    ]
12621
12622    def __init__(
12623        self,
12624        bind_interface=None,
12625        egress_filter=None,
12626        healthy=None,
12627        hostname=None,
12628        id=None,
12629        name=None,
12630        password=None,
12631        port=None,
12632        port_override=None,
12633        secret_store_id=None,
12634        tags=None,
12635        username=None,
12636    ):
12637        self.bind_interface = bind_interface if bind_interface is not None else ''
12638        '''
12639         Bind interface
12640        '''
12641        self.egress_filter = egress_filter if egress_filter is not None else ''
12642        '''
12643         A filter applied to the routing logic to pin datasource to nodes.
12644        '''
12645        self.healthy = healthy if healthy is not None else False
12646        '''
12647         True if the datasource is reachable and the credentials are valid.
12648        '''
12649        self.hostname = hostname if hostname is not None else ''
12650        '''
12651
12652        '''
12653        self.id = id if id is not None else ''
12654        '''
12655         Unique identifier of the Resource.
12656        '''
12657        self.name = name if name is not None else ''
12658        '''
12659         Unique human-readable name of the Resource.
12660        '''
12661        self.password = password if password is not None else ''
12662        '''
12663
12664        '''
12665        self.port = port if port is not None else 0
12666        '''
12667
12668        '''
12669        self.port_override = port_override if port_override is not None else 0
12670        '''
12671
12672        '''
12673        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12674        '''
12675         ID of the secret store containing credentials for this resource, if any.
12676        '''
12677        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12678        '''
12679         Tags is a map of key, value pairs.
12680        '''
12681        self.username = username if username is not None else ''
12682        '''
12683
12684        '''
12685
12686    def __repr__(self):
12687        return '<sdm.SybaseIQ ' + \
12688            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12689            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12690            'healthy: ' + repr(self.healthy) + ' ' +\
12691            'hostname: ' + repr(self.hostname) + ' ' +\
12692            'id: ' + repr(self.id) + ' ' +\
12693            'name: ' + repr(self.name) + ' ' +\
12694            'password: ' + repr(self.password) + ' ' +\
12695            'port: ' + repr(self.port) + ' ' +\
12696            'port_override: ' + repr(self.port_override) + ' ' +\
12697            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12698            'tags: ' + repr(self.tags) + ' ' +\
12699            'username: ' + repr(self.username) + ' ' +\
12700            '>'
12701
12702    def to_dict(self):
12703        return {
12704            'bind_interface': self.bind_interface,
12705            'egress_filter': self.egress_filter,
12706            'healthy': self.healthy,
12707            'hostname': self.hostname,
12708            'id': self.id,
12709            'name': self.name,
12710            'password': self.password,
12711            'port': self.port,
12712            'port_override': self.port_override,
12713            'secret_store_id': self.secret_store_id,
12714            'tags': self.tags,
12715            'username': self.username,
12716        }
12717
12718    @classmethod
12719    def from_dict(cls, d):
12720        return cls(
12721            bind_interface=d.get('bind_interface'),
12722            egress_filter=d.get('egress_filter'),
12723            healthy=d.get('healthy'),
12724            hostname=d.get('hostname'),
12725            id=d.get('id'),
12726            name=d.get('name'),
12727            password=d.get('password'),
12728            port=d.get('port'),
12729            port_override=d.get('port_override'),
12730            secret_store_id=d.get('secret_store_id'),
12731            tags=d.get('tags'),
12732            username=d.get('username'),
12733        )
SybaseIQ( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
12622    def __init__(
12623        self,
12624        bind_interface=None,
12625        egress_filter=None,
12626        healthy=None,
12627        hostname=None,
12628        id=None,
12629        name=None,
12630        password=None,
12631        port=None,
12632        port_override=None,
12633        secret_store_id=None,
12634        tags=None,
12635        username=None,
12636    ):
12637        self.bind_interface = bind_interface if bind_interface is not None else ''
12638        '''
12639         Bind interface
12640        '''
12641        self.egress_filter = egress_filter if egress_filter is not None else ''
12642        '''
12643         A filter applied to the routing logic to pin datasource to nodes.
12644        '''
12645        self.healthy = healthy if healthy is not None else False
12646        '''
12647         True if the datasource is reachable and the credentials are valid.
12648        '''
12649        self.hostname = hostname if hostname is not None else ''
12650        '''
12651
12652        '''
12653        self.id = id if id is not None else ''
12654        '''
12655         Unique identifier of the Resource.
12656        '''
12657        self.name = name if name is not None else ''
12658        '''
12659         Unique human-readable name of the Resource.
12660        '''
12661        self.password = password if password is not None else ''
12662        '''
12663
12664        '''
12665        self.port = port if port is not None else 0
12666        '''
12667
12668        '''
12669        self.port_override = port_override if port_override is not None else 0
12670        '''
12671
12672        '''
12673        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12674        '''
12675         ID of the secret store containing credentials for this resource, if any.
12676        '''
12677        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12678        '''
12679         Tags is a map of key, value pairs.
12680        '''
12681        self.username = username if username is not None else ''
12682        '''
12683
12684        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12702    def to_dict(self):
12703        return {
12704            'bind_interface': self.bind_interface,
12705            'egress_filter': self.egress_filter,
12706            'healthy': self.healthy,
12707            'hostname': self.hostname,
12708            'id': self.id,
12709            'name': self.name,
12710            'password': self.password,
12711            'port': self.port,
12712            'port_override': self.port_override,
12713            'secret_store_id': self.secret_store_id,
12714            'tags': self.tags,
12715            'username': self.username,
12716        }
@classmethod
def from_dict(cls, d)
12718    @classmethod
12719    def from_dict(cls, d):
12720        return cls(
12721            bind_interface=d.get('bind_interface'),
12722            egress_filter=d.get('egress_filter'),
12723            healthy=d.get('healthy'),
12724            hostname=d.get('hostname'),
12725            id=d.get('id'),
12726            name=d.get('name'),
12727            password=d.get('password'),
12728            port=d.get('port'),
12729            port_override=d.get('port_override'),
12730            secret_store_id=d.get('secret_store_id'),
12731            tags=d.get('tags'),
12732            username=d.get('username'),
12733        )
class Tag:
12736class Tag:
12737    '''
12738
12739    '''
12740    __slots__ = [
12741        'name',
12742        'value',
12743    ]
12744
12745    def __init__(
12746        self,
12747        name=None,
12748        value=None,
12749    ):
12750        self.name = name if name is not None else ''
12751        '''
12752
12753        '''
12754        self.value = value if value is not None else ''
12755        '''
12756
12757        '''
12758
12759    def __repr__(self):
12760        return '<sdm.Tag ' + \
12761            'name: ' + repr(self.name) + ' ' +\
12762            'value: ' + repr(self.value) + ' ' +\
12763            '>'
12764
12765    def to_dict(self):
12766        return {
12767            'name': self.name,
12768            'value': self.value,
12769        }
12770
12771    @classmethod
12772    def from_dict(cls, d):
12773        return cls(
12774            name=d.get('name'),
12775            value=d.get('value'),
12776        )
Tag(name=None, value=None)
12745    def __init__(
12746        self,
12747        name=None,
12748        value=None,
12749    ):
12750        self.name = name if name is not None else ''
12751        '''
12752
12753        '''
12754        self.value = value if value is not None else ''
12755        '''
12756
12757        '''
name
value
def to_dict(self)
12765    def to_dict(self):
12766        return {
12767            'name': self.name,
12768            'value': self.value,
12769        }
@classmethod
def from_dict(cls, d)
12771    @classmethod
12772    def from_dict(cls, d):
12773        return cls(
12774            name=d.get('name'),
12775            value=d.get('value'),
12776        )
class Teradata:
12779class Teradata:
12780    '''
12781
12782    '''
12783    __slots__ = [
12784        'bind_interface',
12785        'egress_filter',
12786        'healthy',
12787        'hostname',
12788        'id',
12789        'name',
12790        'password',
12791        'port',
12792        'port_override',
12793        'secret_store_id',
12794        'tags',
12795        'username',
12796    ]
12797
12798    def __init__(
12799        self,
12800        bind_interface=None,
12801        egress_filter=None,
12802        healthy=None,
12803        hostname=None,
12804        id=None,
12805        name=None,
12806        password=None,
12807        port=None,
12808        port_override=None,
12809        secret_store_id=None,
12810        tags=None,
12811        username=None,
12812    ):
12813        self.bind_interface = bind_interface if bind_interface is not None else ''
12814        '''
12815         Bind interface
12816        '''
12817        self.egress_filter = egress_filter if egress_filter is not None else ''
12818        '''
12819         A filter applied to the routing logic to pin datasource to nodes.
12820        '''
12821        self.healthy = healthy if healthy is not None else False
12822        '''
12823         True if the datasource is reachable and the credentials are valid.
12824        '''
12825        self.hostname = hostname if hostname is not None else ''
12826        '''
12827
12828        '''
12829        self.id = id if id is not None else ''
12830        '''
12831         Unique identifier of the Resource.
12832        '''
12833        self.name = name if name is not None else ''
12834        '''
12835         Unique human-readable name of the Resource.
12836        '''
12837        self.password = password if password is not None else ''
12838        '''
12839
12840        '''
12841        self.port = port if port is not None else 0
12842        '''
12843
12844        '''
12845        self.port_override = port_override if port_override is not None else 0
12846        '''
12847
12848        '''
12849        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12850        '''
12851         ID of the secret store containing credentials for this resource, if any.
12852        '''
12853        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12854        '''
12855         Tags is a map of key, value pairs.
12856        '''
12857        self.username = username if username is not None else ''
12858        '''
12859
12860        '''
12861
12862    def __repr__(self):
12863        return '<sdm.Teradata ' + \
12864            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12865            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12866            'healthy: ' + repr(self.healthy) + ' ' +\
12867            'hostname: ' + repr(self.hostname) + ' ' +\
12868            'id: ' + repr(self.id) + ' ' +\
12869            'name: ' + repr(self.name) + ' ' +\
12870            'password: ' + repr(self.password) + ' ' +\
12871            'port: ' + repr(self.port) + ' ' +\
12872            'port_override: ' + repr(self.port_override) + ' ' +\
12873            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12874            'tags: ' + repr(self.tags) + ' ' +\
12875            'username: ' + repr(self.username) + ' ' +\
12876            '>'
12877
12878    def to_dict(self):
12879        return {
12880            'bind_interface': self.bind_interface,
12881            'egress_filter': self.egress_filter,
12882            'healthy': self.healthy,
12883            'hostname': self.hostname,
12884            'id': self.id,
12885            'name': self.name,
12886            'password': self.password,
12887            'port': self.port,
12888            'port_override': self.port_override,
12889            'secret_store_id': self.secret_store_id,
12890            'tags': self.tags,
12891            'username': self.username,
12892        }
12893
12894    @classmethod
12895    def from_dict(cls, d):
12896        return cls(
12897            bind_interface=d.get('bind_interface'),
12898            egress_filter=d.get('egress_filter'),
12899            healthy=d.get('healthy'),
12900            hostname=d.get('hostname'),
12901            id=d.get('id'),
12902            name=d.get('name'),
12903            password=d.get('password'),
12904            port=d.get('port'),
12905            port_override=d.get('port_override'),
12906            secret_store_id=d.get('secret_store_id'),
12907            tags=d.get('tags'),
12908            username=d.get('username'),
12909        )
Teradata( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
12798    def __init__(
12799        self,
12800        bind_interface=None,
12801        egress_filter=None,
12802        healthy=None,
12803        hostname=None,
12804        id=None,
12805        name=None,
12806        password=None,
12807        port=None,
12808        port_override=None,
12809        secret_store_id=None,
12810        tags=None,
12811        username=None,
12812    ):
12813        self.bind_interface = bind_interface if bind_interface is not None else ''
12814        '''
12815         Bind interface
12816        '''
12817        self.egress_filter = egress_filter if egress_filter is not None else ''
12818        '''
12819         A filter applied to the routing logic to pin datasource to nodes.
12820        '''
12821        self.healthy = healthy if healthy is not None else False
12822        '''
12823         True if the datasource is reachable and the credentials are valid.
12824        '''
12825        self.hostname = hostname if hostname is not None else ''
12826        '''
12827
12828        '''
12829        self.id = id if id is not None else ''
12830        '''
12831         Unique identifier of the Resource.
12832        '''
12833        self.name = name if name is not None else ''
12834        '''
12835         Unique human-readable name of the Resource.
12836        '''
12837        self.password = password if password is not None else ''
12838        '''
12839
12840        '''
12841        self.port = port if port is not None else 0
12842        '''
12843
12844        '''
12845        self.port_override = port_override if port_override is not None else 0
12846        '''
12847
12848        '''
12849        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12850        '''
12851         ID of the secret store containing credentials for this resource, if any.
12852        '''
12853        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12854        '''
12855         Tags is a map of key, value pairs.
12856        '''
12857        self.username = username if username is not None else ''
12858        '''
12859
12860        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12878    def to_dict(self):
12879        return {
12880            'bind_interface': self.bind_interface,
12881            'egress_filter': self.egress_filter,
12882            'healthy': self.healthy,
12883            'hostname': self.hostname,
12884            'id': self.id,
12885            'name': self.name,
12886            'password': self.password,
12887            'port': self.port,
12888            'port_override': self.port_override,
12889            'secret_store_id': self.secret_store_id,
12890            'tags': self.tags,
12891            'username': self.username,
12892        }
@classmethod
def from_dict(cls, d)
12894    @classmethod
12895    def from_dict(cls, d):
12896        return cls(
12897            bind_interface=d.get('bind_interface'),
12898            egress_filter=d.get('egress_filter'),
12899            healthy=d.get('healthy'),
12900            hostname=d.get('hostname'),
12901            id=d.get('id'),
12902            name=d.get('name'),
12903            password=d.get('password'),
12904            port=d.get('port'),
12905            port_override=d.get('port_override'),
12906            secret_store_id=d.get('secret_store_id'),
12907            tags=d.get('tags'),
12908            username=d.get('username'),
12909        )
class UpdateResponseMetadata:
12912class UpdateResponseMetadata:
12913    '''
12914     UpdateResponseMetadata is reserved for future use.
12915    '''
12916    __slots__ = []
12917
12918    def __init__(self, ):
12919        pass
12920
12921    def __repr__(self):
12922        return '<sdm.UpdateResponseMetadata ' + \
12923            '>'
12924
12925    def to_dict(self):
12926        return {}
12927
12928    @classmethod
12929    def from_dict(cls, d):
12930        return cls()

UpdateResponseMetadata is reserved for future use.

UpdateResponseMetadata()
12918    def __init__(self, ):
12919        pass
def to_dict(self)
12925    def to_dict(self):
12926        return {}
@classmethod
def from_dict(cls, d)
12928    @classmethod
12929    def from_dict(cls, d):
12930        return cls()
class User:
12933class User:
12934    '''
12935     A User can connect to resources they are granted directly, or granted
12936     via roles.
12937    '''
12938    __slots__ = [
12939        'email',
12940        'first_name',
12941        'id',
12942        'last_name',
12943        'suspended',
12944        'tags',
12945    ]
12946
12947    def __init__(
12948        self,
12949        email=None,
12950        first_name=None,
12951        id=None,
12952        last_name=None,
12953        suspended=None,
12954        tags=None,
12955    ):
12956        self.email = email if email is not None else ''
12957        '''
12958         The User's email address. Must be unique.
12959        '''
12960        self.first_name = first_name if first_name is not None else ''
12961        '''
12962         The User's first name.
12963        '''
12964        self.id = id if id is not None else ''
12965        '''
12966         Unique identifier of the User.
12967        '''
12968        self.last_name = last_name if last_name is not None else ''
12969        '''
12970         The User's last name.
12971        '''
12972        self.suspended = suspended if suspended is not None else False
12973        '''
12974         The User's suspended state.
12975        '''
12976        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12977        '''
12978         Tags is a map of key, value pairs.
12979        '''
12980
12981    def __repr__(self):
12982        return '<sdm.User ' + \
12983            'email: ' + repr(self.email) + ' ' +\
12984            'first_name: ' + repr(self.first_name) + ' ' +\
12985            'id: ' + repr(self.id) + ' ' +\
12986            'last_name: ' + repr(self.last_name) + ' ' +\
12987            'suspended: ' + repr(self.suspended) + ' ' +\
12988            'tags: ' + repr(self.tags) + ' ' +\
12989            '>'
12990
12991    def to_dict(self):
12992        return {
12993            'email': self.email,
12994            'first_name': self.first_name,
12995            'id': self.id,
12996            'last_name': self.last_name,
12997            'suspended': self.suspended,
12998            'tags': self.tags,
12999        }
13000
13001    @classmethod
13002    def from_dict(cls, d):
13003        return cls(
13004            email=d.get('email'),
13005            first_name=d.get('first_name'),
13006            id=d.get('id'),
13007            last_name=d.get('last_name'),
13008            suspended=d.get('suspended'),
13009            tags=d.get('tags'),
13010        )

A User can connect to resources they are granted directly, or granted via roles.

User( email=None, first_name=None, id=None, last_name=None, suspended=None, tags=None)
12947    def __init__(
12948        self,
12949        email=None,
12950        first_name=None,
12951        id=None,
12952        last_name=None,
12953        suspended=None,
12954        tags=None,
12955    ):
12956        self.email = email if email is not None else ''
12957        '''
12958         The User's email address. Must be unique.
12959        '''
12960        self.first_name = first_name if first_name is not None else ''
12961        '''
12962         The User's first name.
12963        '''
12964        self.id = id if id is not None else ''
12965        '''
12966         Unique identifier of the User.
12967        '''
12968        self.last_name = last_name if last_name is not None else ''
12969        '''
12970         The User's last name.
12971        '''
12972        self.suspended = suspended if suspended is not None else False
12973        '''
12974         The User's suspended state.
12975        '''
12976        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12977        '''
12978         Tags is a map of key, value pairs.
12979        '''
email

The User's email address. Must be unique.

first_name

The User's first name.

id

Unique identifier of the User.

last_name

The User's last name.

suspended

The User's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
12991    def to_dict(self):
12992        return {
12993            'email': self.email,
12994            'first_name': self.first_name,
12995            'id': self.id,
12996            'last_name': self.last_name,
12997            'suspended': self.suspended,
12998            'tags': self.tags,
12999        }
@classmethod
def from_dict(cls, d)
13001    @classmethod
13002    def from_dict(cls, d):
13003        return cls(
13004            email=d.get('email'),
13005            first_name=d.get('first_name'),
13006            id=d.get('id'),
13007            last_name=d.get('last_name'),
13008            suspended=d.get('suspended'),
13009            tags=d.get('tags'),
13010        )
class VaultAppRoleStore:
13013class VaultAppRoleStore:
13014    '''
13015
13016    '''
13017    __slots__ = [
13018        'id',
13019        'name',
13020        'namespace',
13021        'server_address',
13022        'tags',
13023    ]
13024
13025    def __init__(
13026        self,
13027        id=None,
13028        name=None,
13029        namespace=None,
13030        server_address=None,
13031        tags=None,
13032    ):
13033        self.id = id if id is not None else ''
13034        '''
13035         Unique identifier of the SecretStore.
13036        '''
13037        self.name = name if name is not None else ''
13038        '''
13039         Unique human-readable name of the SecretStore.
13040        '''
13041        self.namespace = namespace if namespace is not None else ''
13042        '''
13043
13044        '''
13045        self.server_address = server_address if server_address is not None else ''
13046        '''
13047
13048        '''
13049        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13050        '''
13051         Tags is a map of key, value pairs.
13052        '''
13053
13054    def __repr__(self):
13055        return '<sdm.VaultAppRoleStore ' + \
13056            'id: ' + repr(self.id) + ' ' +\
13057            'name: ' + repr(self.name) + ' ' +\
13058            'namespace: ' + repr(self.namespace) + ' ' +\
13059            'server_address: ' + repr(self.server_address) + ' ' +\
13060            'tags: ' + repr(self.tags) + ' ' +\
13061            '>'
13062
13063    def to_dict(self):
13064        return {
13065            'id': self.id,
13066            'name': self.name,
13067            'namespace': self.namespace,
13068            'server_address': self.server_address,
13069            'tags': self.tags,
13070        }
13071
13072    @classmethod
13073    def from_dict(cls, d):
13074        return cls(
13075            id=d.get('id'),
13076            name=d.get('name'),
13077            namespace=d.get('namespace'),
13078            server_address=d.get('server_address'),
13079            tags=d.get('tags'),
13080        )
VaultAppRoleStore(id=None, name=None, namespace=None, server_address=None, tags=None)
13025    def __init__(
13026        self,
13027        id=None,
13028        name=None,
13029        namespace=None,
13030        server_address=None,
13031        tags=None,
13032    ):
13033        self.id = id if id is not None else ''
13034        '''
13035         Unique identifier of the SecretStore.
13036        '''
13037        self.name = name if name is not None else ''
13038        '''
13039         Unique human-readable name of the SecretStore.
13040        '''
13041        self.namespace = namespace if namespace is not None else ''
13042        '''
13043
13044        '''
13045        self.server_address = server_address if server_address is not None else ''
13046        '''
13047
13048        '''
13049        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13050        '''
13051         Tags is a map of key, value pairs.
13052        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
13063    def to_dict(self):
13064        return {
13065            'id': self.id,
13066            'name': self.name,
13067            'namespace': self.namespace,
13068            'server_address': self.server_address,
13069            'tags': self.tags,
13070        }
@classmethod
def from_dict(cls, d)
13072    @classmethod
13073    def from_dict(cls, d):
13074        return cls(
13075            id=d.get('id'),
13076            name=d.get('name'),
13077            namespace=d.get('namespace'),
13078            server_address=d.get('server_address'),
13079            tags=d.get('tags'),
13080        )
class VaultTLSStore:
13083class VaultTLSStore:
13084    '''
13085
13086    '''
13087    __slots__ = [
13088        'ca_cert_path',
13089        'client_cert_path',
13090        'client_key_path',
13091        'id',
13092        'name',
13093        'namespace',
13094        'server_address',
13095        'tags',
13096    ]
13097
13098    def __init__(
13099        self,
13100        ca_cert_path=None,
13101        client_cert_path=None,
13102        client_key_path=None,
13103        id=None,
13104        name=None,
13105        namespace=None,
13106        server_address=None,
13107        tags=None,
13108    ):
13109        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
13110        '''
13111
13112        '''
13113        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
13114        '''
13115
13116        '''
13117        self.client_key_path = client_key_path if client_key_path is not None else ''
13118        '''
13119
13120        '''
13121        self.id = id if id is not None else ''
13122        '''
13123         Unique identifier of the SecretStore.
13124        '''
13125        self.name = name if name is not None else ''
13126        '''
13127         Unique human-readable name of the SecretStore.
13128        '''
13129        self.namespace = namespace if namespace is not None else ''
13130        '''
13131
13132        '''
13133        self.server_address = server_address if server_address is not None else ''
13134        '''
13135
13136        '''
13137        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13138        '''
13139         Tags is a map of key, value pairs.
13140        '''
13141
13142    def __repr__(self):
13143        return '<sdm.VaultTLSStore ' + \
13144            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
13145            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
13146            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
13147            'id: ' + repr(self.id) + ' ' +\
13148            'name: ' + repr(self.name) + ' ' +\
13149            'namespace: ' + repr(self.namespace) + ' ' +\
13150            'server_address: ' + repr(self.server_address) + ' ' +\
13151            'tags: ' + repr(self.tags) + ' ' +\
13152            '>'
13153
13154    def to_dict(self):
13155        return {
13156            'ca_cert_path': self.ca_cert_path,
13157            'client_cert_path': self.client_cert_path,
13158            'client_key_path': self.client_key_path,
13159            'id': self.id,
13160            'name': self.name,
13161            'namespace': self.namespace,
13162            'server_address': self.server_address,
13163            'tags': self.tags,
13164        }
13165
13166    @classmethod
13167    def from_dict(cls, d):
13168        return cls(
13169            ca_cert_path=d.get('ca_cert_path'),
13170            client_cert_path=d.get('client_cert_path'),
13171            client_key_path=d.get('client_key_path'),
13172            id=d.get('id'),
13173            name=d.get('name'),
13174            namespace=d.get('namespace'),
13175            server_address=d.get('server_address'),
13176            tags=d.get('tags'),
13177        )
VaultTLSStore( ca_cert_path=None, client_cert_path=None, client_key_path=None, id=None, name=None, namespace=None, server_address=None, tags=None)
13098    def __init__(
13099        self,
13100        ca_cert_path=None,
13101        client_cert_path=None,
13102        client_key_path=None,
13103        id=None,
13104        name=None,
13105        namespace=None,
13106        server_address=None,
13107        tags=None,
13108    ):
13109        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
13110        '''
13111
13112        '''
13113        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
13114        '''
13115
13116        '''
13117        self.client_key_path = client_key_path if client_key_path is not None else ''
13118        '''
13119
13120        '''
13121        self.id = id if id is not None else ''
13122        '''
13123         Unique identifier of the SecretStore.
13124        '''
13125        self.name = name if name is not None else ''
13126        '''
13127         Unique human-readable name of the SecretStore.
13128        '''
13129        self.namespace = namespace if namespace is not None else ''
13130        '''
13131
13132        '''
13133        self.server_address = server_address if server_address is not None else ''
13134        '''
13135
13136        '''
13137        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13138        '''
13139         Tags is a map of key, value pairs.
13140        '''
ca_cert_path
client_cert_path
client_key_path
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
13154    def to_dict(self):
13155        return {
13156            'ca_cert_path': self.ca_cert_path,
13157            'client_cert_path': self.client_cert_path,
13158            'client_key_path': self.client_key_path,
13159            'id': self.id,
13160            'name': self.name,
13161            'namespace': self.namespace,
13162            'server_address': self.server_address,
13163            'tags': self.tags,
13164        }
@classmethod
def from_dict(cls, d)
13166    @classmethod
13167    def from_dict(cls, d):
13168        return cls(
13169            ca_cert_path=d.get('ca_cert_path'),
13170            client_cert_path=d.get('client_cert_path'),
13171            client_key_path=d.get('client_key_path'),
13172            id=d.get('id'),
13173            name=d.get('name'),
13174            namespace=d.get('namespace'),
13175            server_address=d.get('server_address'),
13176            tags=d.get('tags'),
13177        )
class VaultTokenStore:
13180class VaultTokenStore:
13181    '''
13182
13183    '''
13184    __slots__ = [
13185        'id',
13186        'name',
13187        'namespace',
13188        'server_address',
13189        'tags',
13190    ]
13191
13192    def __init__(
13193        self,
13194        id=None,
13195        name=None,
13196        namespace=None,
13197        server_address=None,
13198        tags=None,
13199    ):
13200        self.id = id if id is not None else ''
13201        '''
13202         Unique identifier of the SecretStore.
13203        '''
13204        self.name = name if name is not None else ''
13205        '''
13206         Unique human-readable name of the SecretStore.
13207        '''
13208        self.namespace = namespace if namespace is not None else ''
13209        '''
13210
13211        '''
13212        self.server_address = server_address if server_address is not None else ''
13213        '''
13214
13215        '''
13216        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13217        '''
13218         Tags is a map of key, value pairs.
13219        '''
13220
13221    def __repr__(self):
13222        return '<sdm.VaultTokenStore ' + \
13223            'id: ' + repr(self.id) + ' ' +\
13224            'name: ' + repr(self.name) + ' ' +\
13225            'namespace: ' + repr(self.namespace) + ' ' +\
13226            'server_address: ' + repr(self.server_address) + ' ' +\
13227            'tags: ' + repr(self.tags) + ' ' +\
13228            '>'
13229
13230    def to_dict(self):
13231        return {
13232            'id': self.id,
13233            'name': self.name,
13234            'namespace': self.namespace,
13235            'server_address': self.server_address,
13236            'tags': self.tags,
13237        }
13238
13239    @classmethod
13240    def from_dict(cls, d):
13241        return cls(
13242            id=d.get('id'),
13243            name=d.get('name'),
13244            namespace=d.get('namespace'),
13245            server_address=d.get('server_address'),
13246            tags=d.get('tags'),
13247        )
VaultTokenStore(id=None, name=None, namespace=None, server_address=None, tags=None)
13192    def __init__(
13193        self,
13194        id=None,
13195        name=None,
13196        namespace=None,
13197        server_address=None,
13198        tags=None,
13199    ):
13200        self.id = id if id is not None else ''
13201        '''
13202         Unique identifier of the SecretStore.
13203        '''
13204        self.name = name if name is not None else ''
13205        '''
13206         Unique human-readable name of the SecretStore.
13207        '''
13208        self.namespace = namespace if namespace is not None else ''
13209        '''
13210
13211        '''
13212        self.server_address = server_address if server_address is not None else ''
13213        '''
13214
13215        '''
13216        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13217        '''
13218         Tags is a map of key, value pairs.
13219        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
13230    def to_dict(self):
13231        return {
13232            'id': self.id,
13233            'name': self.name,
13234            'namespace': self.namespace,
13235            'server_address': self.server_address,
13236            'tags': self.tags,
13237        }
@classmethod
def from_dict(cls, d)
13239    @classmethod
13240    def from_dict(cls, d):
13241        return cls(
13242            id=d.get('id'),
13243            name=d.get('name'),
13244            namespace=d.get('namespace'),
13245            server_address=d.get('server_address'),
13246            tags=d.get('tags'),
13247        )